xref: /aoo41x/main/sc/source/ui/unoobj/nameuno.cxx (revision 5b2f55dd)

/**************************************************************
 *
 * 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 <svl/smplhint.hxx>

#include <com/sun/star/sheet/NamedRangeFlag.hpp>
#include <com/sun/star/awt/XBitmap.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>

using namespace ::com::sun::star;


#include "nameuno.hxx"
#include "miscuno.hxx"
#include "cellsuno.hxx"
#include "convuno.hxx"
#include "targuno.hxx"
#include "tokenuno.hxx"
#include "tokenarray.hxx"
#include "docsh.hxx"
#include "docfunc.hxx"
#include "rangenam.hxx"
//CHINA001 #include "namecrea.hxx"		// NAME_TOP etc.
#include "unoguard.hxx"
#include "unonames.hxx"

#include "scui_def.hxx" //CHINA001

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

const SfxItemPropertyMapEntry* lcl_GetNamedRangeMap()
{
    static SfxItemPropertyMapEntry aNamedRangeMap_Impl[] =
	{
        {MAP_CHAR_LEN(SC_UNO_LINKDISPBIT),      0,  &getCppuType((uno::Reference<awt::XBitmap>*)0), beans::PropertyAttribute::READONLY, 0 },
        {MAP_CHAR_LEN(SC_UNO_LINKDISPNAME),     0,  &getCppuType((rtl::OUString*)0),                beans::PropertyAttribute::READONLY, 0 },
        {MAP_CHAR_LEN(SC_UNONAME_TOKENINDEX),   0,  &getCppuType((sal_Int32*)0),                    beans::PropertyAttribute::READONLY, 0 },
        {MAP_CHAR_LEN(SC_UNONAME_ISSHAREDFMLA), 0,  &getBooleanCppuType(),                          0, 0 },
        {0,0,0,0,0,0}
	};
	return aNamedRangeMap_Impl;
}

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

#define SCNAMEDRANGEOBJ_SERVICE		"com.sun.star.sheet.NamedRange"

SC_SIMPLE_SERVICE_INFO( ScLabelRangeObj, "ScLabelRangeObj", "com.sun.star.sheet.LabelRange" )
SC_SIMPLE_SERVICE_INFO( ScLabelRangesObj, "ScLabelRangesObj", "com.sun.star.sheet.LabelRanges" )
SC_SIMPLE_SERVICE_INFO( ScNamedRangesObj, "ScNamedRangesObj", "com.sun.star.sheet.NamedRanges" )

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

sal_Bool lcl_UserVisibleName( const ScRangeData* pData )
{
	//!	als Methode an ScRangeData

	return ( pData && !pData->HasType( RT_DATABASE ) && !pData->HasType( RT_SHARED ) );
}

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

ScNamedRangeObj::ScNamedRangeObj(ScDocShell* pDocSh, const String& rNm, const String& rScopeName) :
	pDocShell( pDocSh ),
	aName( rNm ),
	aScopeName(rScopeName)
{
	pDocShell->GetDocument()->AddUnoObject(*this);
}

ScNamedRangeObj::~ScNamedRangeObj()
{
	if (pDocShell)
		pDocShell->GetDocument()->RemoveUnoObject(*this);
}

void ScNamedRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
	//	Ref-Update interessiert nicht

	if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
		pDocShell = NULL;		// ungueltig geworden
}

// Hilfsfuntionen

ScRangeData* ScNamedRangeObj::GetRangeData_Impl()
{
	ScRangeData* pRet = NULL;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nPos = 0;
			SCTAB nameScope = MAXTABCOUNT;
			if ( aScopeName != EMPTY_STRING )
			{
				pDocShell->GetDocument()->GetTable( aScopeName, nameScope );
			}
			if (pNames->SearchName( aName, nPos, nameScope ))
			{
				pRet = (*pNames)[nPos];
				pRet->ValidateTabRefs();		// adjust relative tab refs to valid tables
			}
		}
	}
	return pRet;
}

// sheet::XNamedRange

void ScNamedRangeObj::Modify_Impl( const String* pNewRangeName, const ScTokenArray* pNewTokens, const String* pNewContent,
									const ScAddress* pNewPos, const sal_uInt16* pNewType,
                                    const formula::FormulaGrammar::Grammar eGrammar, const String* pNewScopeName )
{
       if (pDocShell)
       {
              ScDocument* pDoc = pDocShell->GetDocument();
              ScRangeName* pNames = pDoc->GetRangeName();
              if (pNames)
              {
                     sal_uInt16 nPos = 0;
                     SCTAB nameScope = MAXTABCOUNT;
                     if (aScopeName != EMPTY_STRING )
                         pDoc->GetTable(aScopeName, nameScope);

                     if (pNames->SearchName( aName, nPos, nameScope ))
                     {
                            SCTAB newNameScope = MAXTABCOUNT;
                            if (pNewScopeName && *pNewScopeName != EMPTY_STRING && !pDoc->GetTable(*pNewScopeName, newNameScope))
                                return;
							//added for namerange renew
							else if (!pNewScopeName || *pNewScopeName == EMPTY_STRING )
								newNameScope = nameScope;
							//end of add

                            ScRangeData* pOld = (*pNames)[nPos];

                            String aInsName(pOld->GetName());
                            if (pNewRangeName)
                                aInsName = *pNewRangeName;
                            String aContent;                            // Content string based =>
                            pOld->GetSymbol( aContent, eGrammar);   // no problems with changed positions and such.
                            if (pNewContent)
                                aContent = *pNewContent;
                            ScAddress aPos(pOld->GetPos());
                            if (pNewPos)
                                aPos = *pNewPos;
                            sal_uInt16 nType = pOld->GetType();
                            if (pNewType)
                                nType = *pNewType;

                            ScRangeData* pNew = NULL;
                            if ( pNewTokens )
                                pNew = new ScRangeData( pDoc, aInsName, *pNewTokens, aPos, nType );
                            else
                                pNew = new ScRangeData( pDoc, aInsName, aContent, aPos, nType, eGrammar );
                            pNew->SetIndex( pOld->GetIndex() );
                            pNew->SetRangeScope(newNameScope);

							const bool bSupportUndo(!pDoc->IsImportingXML());
							if ( bSupportUndo )
							{
								ScRangeName* pNewRanges = new ScRangeName( *pNames );
								pNewRanges->AtFree( nPos );
								if ( pNewRanges->Insert(pNew) )
								{
									 ScDocFunc aFunc(*pDocShell);
									 aFunc.SetNewRangeNames( pNewRanges, sal_True );
									 aName = aInsName;	//! broadcast?
									 aScopeName = pNewScopeName ? *pNewScopeName : aScopeName;
								}
								else
								{
									 delete pNew;		//! uno::Exception/Fehler oder so
									 delete pNewRanges;
								}
							}
							else
							{
								pNames->AtFree( nPos );
								if ( pNames->Insert(pNew) )
								{
									 ScDocFunc aFunc(*pDocShell);
									 aFunc.SetNewRangeNames( pNames, sal_True );
									 aName = aInsName;	//! broadcast?
									 aScopeName = pNewScopeName ? *pNewScopeName : aScopeName;
								}
								else
								{
									 delete pNew;		//! uno::Exception/Fehler oder so
								}
							}
                       }
              }
       }
}


rtl::OUString SAL_CALL ScNamedRangeObj::getName() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return aName;
}

void SAL_CALL ScNamedRangeObj::setName( const rtl::OUString& aNewName )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	//!	Formeln anpassen ?????

	String aNewStr(aNewName);
    // GRAM_PODF_A1 for API compatibility.
	Modify_Impl( &aNewStr, NULL, NULL, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );

	if ( aName != aNewStr )					// some error occured...
		throw uno::RuntimeException();		// no other exceptions specified
}
rtl::OUString SAL_CALL ScNamedRangeObj::getScopeName() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return aScopeName;
}

void SAL_CALL ScNamedRangeObj::setScopeAndRangeName( const rtl::OUString& aNewScopeName, const rtl::OUString& aNewRangeName )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	//!	Formeln anpassen ?????

	String aNewRangeStr(aNewRangeName);
	String aNewScopeStr(aNewScopeName);
    // GRAM_PODF_A1 for API compatibility.
	Modify_Impl( &aNewRangeStr, NULL, NULL, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1,  aNewScopeName.getLength() == 0 ? NULL : &aNewScopeStr);

	if ( aScopeName != aNewScopeStr || aName != aNewRangeStr  )					// some error occured...
		throw uno::RuntimeException();		// no other exceptions specified
}


rtl::OUString SAL_CALL ScNamedRangeObj::getContent() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
   	String aContent;
	ScRangeData* pData = GetRangeData_Impl();
	if (pData)
        // GRAM_PODF_A1 for API compatibility.
        pData->GetSymbol( aContent,formula::FormulaGrammar::GRAM_PODF_A1);
	return aContent;
}

void SAL_CALL ScNamedRangeObj::setContent( const rtl::OUString& aContent )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	String aContStr(aContent);
    // GRAM_PODF_A1 for API compatibility.
	Modify_Impl( NULL, NULL, &aContStr, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
}

void ScNamedRangeObj::SetContentWithGrammar( const ::rtl::OUString& aContent,
                                    const formula::FormulaGrammar::Grammar eGrammar )
                                throw(::com::sun::star::uno::RuntimeException)
{
    String aContStr(aContent);
    Modify_Impl( NULL, NULL, &aContStr, NULL, NULL, eGrammar );
}

table::CellAddress SAL_CALL ScNamedRangeObj::getReferencePosition()
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScAddress aPos;
	ScRangeData* pData = GetRangeData_Impl();
	if (pData)
		aPos = pData->GetPos();
	table::CellAddress aAddress;
	aAddress.Column	= aPos.Col();
	aAddress.Row	= aPos.Row();
	aAddress.Sheet	= aPos.Tab();
	if (pDocShell)
	{
		SCTAB nDocTabs = pDocShell->GetDocument()->GetTableCount();
		if ( aAddress.Sheet >= nDocTabs && nDocTabs > 0 )
		{
			//	Even after ValidateTabRefs, the position can be invalid if
			//	the content points to preceding tables. The resulting string
			//	is invalid in any case, so the position is just shifted.
			aAddress.Sheet = nDocTabs - 1;
		}
	}
	return aAddress;
}

void SAL_CALL ScNamedRangeObj::setReferencePosition( const table::CellAddress& aReferencePosition )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScAddress aPos( (SCCOL)aReferencePosition.Column, (SCROW)aReferencePosition.Row, aReferencePosition.Sheet );
    // GRAM_PODF_A1 for API compatibility.
	Modify_Impl( NULL, NULL, NULL, &aPos, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
}

sal_Int32 SAL_CALL ScNamedRangeObj::getType() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	sal_Int32 nType=0;
	ScRangeData* pData = GetRangeData_Impl();
	if (pData)
	{
        // do not return internal RT_* flags
        // see property 'IsSharedFormula' for RT_SHARED
		if ( pData->HasType(RT_CRITERIA) )	nType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
		if ( pData->HasType(RT_PRINTAREA) )	nType |= sheet::NamedRangeFlag::PRINT_AREA;
		if ( pData->HasType(RT_COLHEADER) )	nType |= sheet::NamedRangeFlag::COLUMN_HEADER;
		if ( pData->HasType(RT_ROWHEADER) )	nType |= sheet::NamedRangeFlag::ROW_HEADER;
	}
	return nType;
}

void SAL_CALL ScNamedRangeObj::setType( sal_Int32 nUnoType ) throw(uno::RuntimeException)
{
    // see property 'IsSharedFormula' for RT_SHARED
	ScUnoGuard aGuard;
	sal_uInt16 nNewType = RT_NAME;
	if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA )	nNewType |= RT_CRITERIA;
	if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA )			nNewType |= RT_PRINTAREA;
	if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER )		nNewType |= RT_COLHEADER;
	if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER )			nNewType |= RT_ROWHEADER;

    // GRAM_PODF_A1 for API compatibility.
	Modify_Impl( NULL, NULL, NULL, NULL, &nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
}

// XFormulaTokens

uno::Sequence<sheet::FormulaToken> SAL_CALL ScNamedRangeObj::getTokens() throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    uno::Sequence<sheet::FormulaToken> aSequence;
    ScRangeData* pData = GetRangeData_Impl();
    if (pData && pDocShell)
    {
        ScTokenArray* pTokenArray = pData->GetCode();
        if ( pTokenArray )
            (void)ScTokenConversion::ConvertToTokenSequence( *pDocShell->GetDocument(), aSequence, *pTokenArray );
    }
    return aSequence;
}

void SAL_CALL ScNamedRangeObj::setTokens( const uno::Sequence<sheet::FormulaToken>& rTokens ) throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    if( pDocShell )
    {
        ScTokenArray aTokenArray;
        (void)ScTokenConversion::ConvertToTokenArray( *pDocShell->GetDocument(), aTokenArray, rTokens );
        // GRAM_PODF_A1 for API compatibility.
        Modify_Impl( NULL, &aTokenArray, NULL, NULL, NULL, formula::FormulaGrammar::GRAM_PODF_A1 );
    }
}


// XCellRangeSource

uno::Reference<table::XCellRange> SAL_CALL ScNamedRangeObj::getReferredCells()
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScRange aRange;
	ScRangeData* pData = GetRangeData_Impl();
    if ( pData && pData->IsValidReference( aRange ) )
	{
		//!	static Funktion um ScCellObj/ScCellRangeObj zu erzeugen am ScCellRangeObj ???

		if ( aRange.aStart == aRange.aEnd )
			return new ScCellObj( pDocShell, aRange.aStart );
		else
			return new ScCellRangeObj( pDocShell, aRange );
	}
	return NULL;
}

// beans::XPropertySet

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScNamedRangeObj::getPropertySetInfo()
														throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	static uno::Reference< beans::XPropertySetInfo >  aRef(new SfxItemPropertySetInfo( lcl_GetNamedRangeMap() ));
	return aRef;
}

void SAL_CALL ScNamedRangeObj::setPropertyValue(
                        const rtl::OUString& rPropertyName, const uno::Any& aValue )
				throw(beans::UnknownPropertyException, beans::PropertyVetoException,
						lang::IllegalArgumentException, lang::WrappedTargetException,
						uno::RuntimeException)
{
    ScUnoGuard aGuard;
    if ( rPropertyName.equalsAscii( SC_UNONAME_ISSHAREDFMLA ) )
    {
        bool bIsShared = false;
        if( aValue >>= bIsShared )
        {
            sal_uInt16 nNewType = bIsShared ? RT_SHARED : RT_NAME;
            Modify_Impl( NULL, NULL, NULL, NULL, &nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
        }
    }
}

uno::Any SAL_CALL ScNamedRangeObj::getPropertyValue( const rtl::OUString& rPropertyName )
				throw(beans::UnknownPropertyException, lang::WrappedTargetException,
						uno::RuntimeException)
{
	ScUnoGuard aGuard;
	uno::Any aRet;
    if ( rPropertyName.equalsAscii( SC_UNO_LINKDISPBIT ) )
	{
		//	no target bitmaps for individual entries (would be all equal)
		// ScLinkTargetTypeObj::SetLinkTargetBitmap( aRet, SC_LINKTARGETTYPE_RANGENAME );
	}
    else if ( rPropertyName.equalsAscii( SC_UNO_LINKDISPNAME ) )
		aRet <<= rtl::OUString( aName );
    else if ( rPropertyName.equalsAscii( SC_UNONAME_TOKENINDEX ) )
    {
        // get index for use in formula tokens (read-only)
        ScRangeData* pData = GetRangeData_Impl();
        if (pData)
            aRet <<= static_cast<sal_Int32>(pData->GetIndex());
    }
    else if ( rPropertyName.equalsAscii( SC_UNONAME_ISSHAREDFMLA ) )
    {
        if( ScRangeData* pData = GetRangeData_Impl() )
            aRet <<= static_cast< bool >( pData->HasType( RT_SHARED ) );
    }
	return aRet;
}

SC_IMPL_DUMMY_PROPERTY_LISTENER( ScNamedRangeObj )

// lang::XServiceInfo

rtl::OUString SAL_CALL ScNamedRangeObj::getImplementationName() throw(uno::RuntimeException)
{
    return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ScNamedRangeObj" ) );
}

sal_Bool SAL_CALL ScNamedRangeObj::supportsService( const rtl::OUString& rServiceName )
													throw(uno::RuntimeException)
{
    return rServiceName.equalsAscii( SCNAMEDRANGEOBJ_SERVICE ) ||
           rServiceName.equalsAscii( SCLINKTARGET_SERVICE );
}

uno::Sequence<rtl::OUString> SAL_CALL ScNamedRangeObj::getSupportedServiceNames()
													throw(uno::RuntimeException)
{
	uno::Sequence<rtl::OUString> aRet(2);
    aRet[0] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SCNAMEDRANGEOBJ_SERVICE ) );
    aRet[1] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SCLINKTARGET_SERVICE ) );
	return aRet;
}


// XUnoTunnel

sal_Int64 SAL_CALL ScNamedRangeObj::getSomething(
				const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
{
	if ( rId.getLength() == 16 &&
          0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
									rId.getConstArray(), 16 ) )
	{
        return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
	}
	return 0;
}

// static
const uno::Sequence<sal_Int8>& ScNamedRangeObj::getUnoTunnelId()
{
	static uno::Sequence<sal_Int8> * pSeq = 0;
	if( !pSeq )
	{
		osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
		if( !pSeq )
		{
			static uno::Sequence< sal_Int8 > aSeq( 16 );
			rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
			pSeq = &aSeq;
		}
	}
	return *pSeq;
}

// static
ScNamedRangeObj* ScNamedRangeObj::getImplementation( const uno::Reference<uno::XInterface> xObj )
{
	ScNamedRangeObj* pRet = NULL;
	uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
	if (xUT.is())
        pRet = reinterpret_cast<ScNamedRangeObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
	return pRet;
}

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

ScNamedRangesObj::ScNamedRangesObj(ScDocShell* pDocSh) :
    pDocShell( pDocSh )
{
	pDocShell->GetDocument()->AddUnoObject(*this);
}

ScNamedRangesObj::~ScNamedRangesObj()
{
	if (pDocShell)
		pDocShell->GetDocument()->RemoveUnoObject(*this);
}

void ScNamedRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
	//	Referenz-Update interessiert hier nicht

	if ( rHint.ISA( SfxSimpleHint ) &&
			((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
	{
		pDocShell = NULL;		// ungueltig geworden
	}
}

// sheet::XNamedRanges

ScNamedRangeObj* ScNamedRangesObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
{
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nCount = pNames->GetCount();
			sal_uInt16 nPos = 0;
			for (sal_uInt16 i=0; i<nCount; i++)
			{
				ScRangeData* pData = (*pNames)[i];
				if (lcl_UserVisibleName(pData))			// interne weglassen
				{
					if ( nPos == nIndex )
						return new ScNamedRangeObj( pDocShell, pData->GetName(), pData->GetScopeSheetName() );
					++nPos;
				}
			}
		}
	}
	return NULL;
}

ScNamedRangeObj* ScNamedRangesObj::GetObjectByName_Impl(const rtl::OUString& aName)
{
	if ( pDocShell && hasByName(aName) )
		return new ScNamedRangeObj( pDocShell, String(aName) );
	return NULL;
}

ScNamedRangeObj* ScNamedRangesObj::GetObjectByScopeName_Impl(const ::rtl::OUString& aScopeName, const ::rtl::OUString& aRangeName)
{
     if ( pDocShell && hasByScopeName(aScopeName, aRangeName) )
		return new ScNamedRangeObj( pDocShell, String(aRangeName),String(aScopeName) );
	return NULL;
}
void ScNamedRangesObj::ImplAddNewByScopeAndName(SCTAB aScope, const ::rtl::OUString& aRangeName, const ::rtl::OUString& aContent,
								const ::com::sun::star::table::CellAddress& aPosition, sal_Int32 nUnoType) throw(uno::RuntimeException)
{
	ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, aPosition.Sheet );

	sal_uInt16 nNewType = RT_NAME;
	if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA )	nNewType |= RT_CRITERIA;
	if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA )			nNewType |= RT_PRINTAREA;
	if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER )		nNewType |= RT_COLHEADER;
	if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER )			nNewType |= RT_ROWHEADER;

	bool bDone = false;
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangeName* pNames = pDoc->GetRangeName();
              sal_uInt16 nIndex = 0;
              String aNameStr(aRangeName);
	       String aContStr(aContent);
		if (pNames && !pNames->SearchName(aNameStr, nIndex,aScope))
		{

            // GRAM_PODF_A1 for API compatibility.
                   ScRangeData* pNew = new ScRangeData( pDoc, aNameStr, aContStr,
												aPos, nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );//GRAM_ODFF,//

                   pNew->SetRangeScope(aScope);

				   const bool bSupportUndo(!pDoc->IsImportingXML());
				   if ( bSupportUndo )
				   {
					   ScRangeName* pNewRanges = new ScRangeName( *pNames );
					   if ( pNewRanges->Insert(pNew) )
					   {
							ScDocFunc aFunc(*pDocShell);
							aFunc.SetNewRangeNames( pNewRanges, sal_True );
							bDone = true;
					   }
					   else
					   {
							delete pNew;
							delete pNewRanges;
					   }
				   }
				   else
				   {
					   if ( pNames->Insert(pNew) )
					   {
							ScDocFunc aFunc(*pDocShell);
							aFunc.SetNewRangeNames( pNames, sal_True );
							bDone = true;
					   }
					   else
					   {
							delete pNew;
					   }
				   }
		}
	}

	if (!bDone)
		throw uno::RuntimeException();		// no other exceptions specified
}

void SAL_CALL ScNamedRangesObj::addNewByName( const rtl::OUString& aName,
		const rtl::OUString& aContent, const table::CellAddress& aPosition,
		sal_Int32 nUnoType ) throw(uno::RuntimeException)
{
       ScUnoGuard aGuard;
       ImplAddNewByScopeAndName(MAXTABCOUNT, aName, aContent, aPosition, nUnoType);
}


void SAL_CALL ScNamedRangesObj::addNewByScopeName( const rtl::OUString& aScopeName,const rtl::OUString& aRangeName,
		const rtl::OUString& aContent, const table::CellAddress& aPosition,
		sal_Int32 nUnoType ) throw(uno::RuntimeException)
{
       ScUnoGuard aGuard;
       SCTAB scope = MAXTABCOUNT;
       if (aScopeName.getLength() != 0 && pDocShell &&
		          !pDocShell->GetDocument()->GetTable( String(aScopeName), scope ) )
           throw uno::RuntimeException();
       ImplAddNewByScopeAndName(scope, aRangeName, aContent, aPosition, nUnoType);


}

void SAL_CALL ScNamedRangesObj::addNewFromTitles( const table::CellRangeAddress& aSource,
									sheet::Border aBorder ) throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	//!	das darf kein enum sein, weil mehrere Bits gesetzt sein koennen !!!

	sal_Bool bTop    = ( aBorder == sheet::Border_TOP );
	sal_Bool bLeft   = ( aBorder == sheet::Border_LEFT );
	sal_Bool bBottom = ( aBorder == sheet::Border_BOTTOM );
	sal_Bool bRight  = ( aBorder == sheet::Border_RIGHT );

	ScRange aRange;
	ScUnoConversion::FillScRange( aRange, aSource );

	sal_uInt16 nFlags = 0;
	if (bTop)	 nFlags |= NAME_TOP;
	if (bLeft)	 nFlags |= NAME_LEFT;
	if (bBottom) nFlags |= NAME_BOTTOM;
	if (bRight)	 nFlags |= NAME_RIGHT;

	if (nFlags)
	{
		ScDocFunc aFunc(*pDocShell);
		aFunc.CreateNames( aRange, nFlags, sal_True );
	}
}

void ScNamedRangesObj::ImplRemoveByScopeAndName(SCTAB aScope, const ::rtl::OUString& aRangeName)
								throw(uno::RuntimeException)
{
	bool bDone = false;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nPos = 0;
			if (pNames->SearchName( String(aRangeName), nPos, aScope ))
				if ( lcl_UserVisibleName((*pNames)[nPos]) )
				{
                                   ScRangeName* pNewRanges = new ScRangeName(*pNames);
					pNewRanges->AtFree(nPos);
					ScDocFunc aFunc(*pDocShell);
                                   aFunc.SetNewRangeNames( pNewRanges, sal_True );
					bDone = true;
				}
		}
	}

	if (!bDone)
		throw uno::RuntimeException();		// no other exceptions specified
}

void SAL_CALL ScNamedRangesObj::removeByName( const rtl::OUString& aName )
												throw(uno::RuntimeException)
{
     ScUnoGuard aGuard;
     ImplRemoveByScopeAndName(MAXTABCOUNT, aName);
}


void SAL_CALL ScNamedRangesObj::removeByScopeName( const ::rtl::OUString& aScopeName, const ::rtl::OUString& aRangeName )
								throw(uno::RuntimeException)
{
       ScUnoGuard aGuard;
       SCTAB scope = MAXTABCOUNT;
	if (aScopeName.getLength() != 0 && pDocShell &&
		                 !pDocShell->GetDocument()->GetTable( String(aScopeName), scope ))
           throw uno::RuntimeException();
	ImplRemoveByScopeAndName(scope, aRangeName);
}


void SAL_CALL ScNamedRangesObj::outputList( const table::CellAddress& aOutputPosition )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScAddress aPos( (SCCOL)aOutputPosition.Column, (SCROW)aOutputPosition.Row, aOutputPosition.Sheet );
	if (pDocShell)
	{
		ScDocFunc aFunc(*pDocShell);
		aFunc.InsertNameList( aPos, sal_True );
	}
}

// container::XEnumerationAccess

uno::Reference<container::XEnumeration> SAL_CALL ScNamedRangesObj::createEnumeration()
													throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
    return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.NamedRangesEnumeration")));
}

// container::XIndexAccess

sal_Int32 SAL_CALL ScNamedRangesObj::getCount() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	long nRet = 0;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nCount = pNames->GetCount();
			for (sal_uInt16 i=0; i<nCount; i++)
				if (lcl_UserVisibleName( (*pNames)[i] ))	// interne weglassen
					++nRet;
		}
	}
	return nRet;
}

uno::Any SAL_CALL ScNamedRangesObj::getByIndex( sal_Int32 nIndex )
							throw(lang::IndexOutOfBoundsException,
									lang::WrappedTargetException, uno::RuntimeException)
{
	ScUnoGuard aGuard;
	uno::Reference< sheet::XNamedRange2 >  xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
	if ( xRange.is() )
        return uno::makeAny(xRange);
	else
		throw lang::IndexOutOfBoundsException();
//    return uno::Any();
}

uno::Type SAL_CALL ScNamedRangesObj::getElementType() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return ::getCppuType((const uno::Reference< sheet::XNamedRange2 >*)0);	// muss zu getByIndex passen
}

sal_Bool SAL_CALL ScNamedRangesObj::hasElements() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return ( getCount() != 0 );
}

uno::Any SAL_CALL ScNamedRangesObj::getByName( const rtl::OUString& aName )
			throw(container::NoSuchElementException,
					lang::WrappedTargetException, uno::RuntimeException)
{
	ScUnoGuard aGuard;
	uno::Reference< sheet::XNamedRange2 >  xRange(GetObjectByName_Impl(aName));
	if ( xRange.is() )
        return uno::makeAny(xRange);
	else
		throw container::NoSuchElementException();
//    return uno::Any();
}

uno::Any SAL_CALL ScNamedRangesObj::getByScopeName( const rtl::OUString& aScopeName, const rtl::OUString& aRangeName )
			throw(container::NoSuchElementException,
					lang::WrappedTargetException, uno::RuntimeException)
{
	ScUnoGuard aGuard;
	uno::Reference< sheet::XNamedRange2 >  xRange(GetObjectByScopeName_Impl(aScopeName, aRangeName));
	if ( xRange.is() )
        return uno::makeAny(xRange);
	else
		throw container::NoSuchElementException();
//    return uno::Any();
}
uno::Sequence<rtl::OUString> SAL_CALL ScNamedRangesObj::getElementNames()
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			long nVisCount = getCount();			// Namen mit lcl_UserVisibleName
			uno::Sequence<rtl::OUString> aSeq(nVisCount);
			rtl::OUString* pAry = aSeq.getArray();

			sal_uInt16 nCount = pNames->GetCount();
			sal_uInt16 nVisPos = 0;
			for (sal_uInt16 i=0; i<nCount; i++)
			{
				ScRangeData* pData = (*pNames)[i];
				if ( lcl_UserVisibleName(pData) )
					pAry[nVisPos++] = pData->GetName();
			}
//			DBG_ASSERT(nVisPos == nVisCount, "huch, verzaehlt?");
			return aSeq;
		}
	}
	return uno::Sequence<rtl::OUString>(0);
}

uno::Sequence< sheet::RangeScopeName > SAL_CALL ScNamedRangesObj::getElementScopeNames()
												throw(uno::RuntimeException)
{
       ScUnoGuard aGuard;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			long nVisCount = getCount();			// Namen mit lcl_UserVisibleName
			uno::Sequence<sheet::RangeScopeName> aSeq(nVisCount);
			sheet::RangeScopeName * pAry = aSeq.getArray();

			sal_uInt16 nCount = pNames->GetCount();
			sal_uInt16 nVisPos = 0;
			for (sal_uInt16 i=0; i<nCount; i++)
			{
				ScRangeData* pData = (*pNames)[i];
				if ( lcl_UserVisibleName(pData) )
				{
					pAry[nVisPos].RangeName = pData->GetName();
					pAry[nVisPos++].ScopeName = pData->GetScopeSheetName();
				}
			}
//			DBG_ASSERT(nVisPos == nVisCount, "huch, verzaehlt?");
			return aSeq;
		}
	}
	return uno::Sequence< sheet::RangeScopeName >(0);
}
sal_Bool SAL_CALL ScNamedRangesObj::hasByName( const rtl::OUString& aName )
										throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	if (pDocShell)
	{
		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nPos = 0;
			if (pNames->SearchName( String(aName), nPos ))
				if ( lcl_UserVisibleName((*pNames)[nPos]) )
					return sal_True;
		}
	}
	return sal_False;
}

sal_Bool SAL_CALL ScNamedRangesObj::hasByScopeName( const ::rtl::OUString& aScopeName, const ::rtl::OUString& aRangeName)
										throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	if (pDocShell)
	{
	       SCTAB scope = MAXTABCOUNT;
	       if (aScopeName.getLength() != 0 && !pDocShell->GetDocument()->GetTable( String(aScopeName), scope ) )
	           return sal_False;

		ScRangeName* pNames = pDocShell->GetDocument()->GetRangeName();
		if (pNames)
		{
			sal_uInt16 nPos = 0;
			if (pNames->SearchName( String(aRangeName), nPos, scope ))
				if ( lcl_UserVisibleName((*pNames)[nPos]) )
					return sal_True;
		}
	}
	return sal_False;
}
/** called from the XActionLockable interface methods on initial locking */
void ScNamedRangesObj::lock()
{
    pDocShell->GetDocument()->CompileNameFormula( sal_True ); // CreateFormulaString
}

/** called from the XActionLockable interface methods on final unlock */
void ScNamedRangesObj::unlock()
{
    pDocShell->GetDocument()->CompileNameFormula( sal_False ); // CompileFormulaString
}

// document::XActionLockable

sal_Bool ScNamedRangesObj::isActionLocked() throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    return pDocShell->GetDocument()->GetNamedRangesLockCount() != 0;
}

void ScNamedRangesObj::addActionLock() throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    ScDocument* pDoc = pDocShell->GetDocument();
    sal_Int16 nLockCount = pDoc->GetNamedRangesLockCount();
    ++nLockCount;
    if ( nLockCount == 1 )
    {
        lock();
    }
    pDoc->SetNamedRangesLockCount( nLockCount );
}

void ScNamedRangesObj::removeActionLock() throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    ScDocument* pDoc = pDocShell->GetDocument();
    sal_Int16 nLockCount = pDoc->GetNamedRangesLockCount();
    if ( nLockCount > 0 )
    {
        --nLockCount;
        if ( nLockCount == 0 )
        {
            unlock();
        }
        pDoc->SetNamedRangesLockCount( nLockCount );
    }
}

void ScNamedRangesObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    if ( nLock >= 0 )
    {
        ScDocument* pDoc = pDocShell->GetDocument();
        sal_Int16 nLockCount = pDoc->GetNamedRangesLockCount();
        if ( nLock == 0 && nLockCount > 0 )
        {
            unlock();
        }
        if ( nLock > 0 && nLockCount == 0 )
        {
            lock();
        }
        pDoc->SetNamedRangesLockCount( nLock );
    }
}

sal_Int16 ScNamedRangesObj::resetActionLocks() throw(uno::RuntimeException)
{
    ScUnoGuard aGuard;
    ScDocument* pDoc = pDocShell->GetDocument();
    sal_Int16 nLockCount = pDoc->GetNamedRangesLockCount();
    if ( nLockCount > 0 )
    {
        unlock();
    }
    pDoc->SetNamedRangesLockCount( 0 );
    return nLockCount;
}

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

ScLabelRangeObj::ScLabelRangeObj(ScDocShell* pDocSh, sal_Bool bCol, const ScRange& rR) :
	pDocShell( pDocSh ),
	bColumn( bCol ),
	aRange( rR )
{
	pDocShell->GetDocument()->AddUnoObject(*this);
}

ScLabelRangeObj::~ScLabelRangeObj()
{
	if (pDocShell)
		pDocShell->GetDocument()->RemoveUnoObject(*this);
}

void ScLabelRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
	//!	Ref-Update !!!

	if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
		pDocShell = NULL;		// ungueltig geworden
}

// Hilfsfuntionen

ScRangePair* ScLabelRangeObj::GetData_Impl()
{
	ScRangePair* pRet = NULL;
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();
		if (pList)
			pRet = pList->Find( aRange );
	}
	return pRet;
}

void ScLabelRangeObj::Modify_Impl( const ScRange* pLabel, const ScRange* pData )
{
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pOldList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();
		if (pOldList)
		{
			ScRangePairListRef xNewList(pOldList->Clone());
			ScRangePair* pEntry = xNewList->Find( aRange );
			if (pEntry)
			{
				xNewList->Remove( pEntry );		// nur aus der Liste entfernt, nicht geloescht

				if ( pLabel )
					pEntry->GetRange(0) = *pLabel;
				if ( pData )
					pEntry->GetRange(1) = *pData;

				xNewList->Join( *pEntry );
				delete pEntry;

				if (bColumn)
					pDoc->GetColNameRangesRef() = xNewList;
				else
					pDoc->GetRowNameRangesRef() = xNewList;

				pDoc->CompileColRowNameFormula();
				pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
				pDocShell->SetDocumentModified();

				//!	Undo ?!?! (hier und aus Dialog)

				if ( pLabel )
					aRange = *pLabel;	// Objekt anpassen, um Range wiederzufinden
			}
		}
	}
}

// sheet::XLabelRange

table::CellRangeAddress SAL_CALL ScLabelRangeObj::getLabelArea()
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	table::CellRangeAddress aRet;
	ScRangePair* pData = GetData_Impl();
	if (pData)
		ScUnoConversion::FillApiRange( aRet, pData->GetRange(0) );
	return aRet;
}

void SAL_CALL ScLabelRangeObj::setLabelArea( const table::CellRangeAddress& aLabelArea )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScRange aLabelRange;
	ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
	Modify_Impl( &aLabelRange, NULL );
}

table::CellRangeAddress SAL_CALL ScLabelRangeObj::getDataArea()
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	table::CellRangeAddress aRet;
	ScRangePair* pData = GetData_Impl();
	if (pData)
		ScUnoConversion::FillApiRange( aRet, pData->GetRange(1) );
	return aRet;
}

void SAL_CALL ScLabelRangeObj::setDataArea( const table::CellRangeAddress& aDataArea )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	ScRange aDataRange;
	ScUnoConversion::FillScRange( aDataRange, aDataArea );
	Modify_Impl( NULL, &aDataRange );
}

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

ScLabelRangesObj::ScLabelRangesObj(ScDocShell* pDocSh, sal_Bool bCol) :
	pDocShell( pDocSh ),
	bColumn( bCol )
{
	pDocShell->GetDocument()->AddUnoObject(*this);
}

ScLabelRangesObj::~ScLabelRangesObj()
{
	if (pDocShell)
		pDocShell->GetDocument()->RemoveUnoObject(*this);
}

void ScLabelRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
	//	Referenz-Update interessiert hier nicht

	if ( rHint.ISA( SfxSimpleHint ) &&
			((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
	{
		pDocShell = NULL;		// ungueltig geworden
	}
}

// sheet::XLabelRanges

ScLabelRangeObj* ScLabelRangesObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
{
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();
		if ( pList && nIndex < pList->Count() )
		{
			ScRangePair* pData = pList->GetObject(nIndex);
			if (pData)
				return new ScLabelRangeObj( pDocShell, bColumn, pData->GetRange(0) );
		}
	}
	return NULL;
}

void SAL_CALL ScLabelRangesObj::addNew( const table::CellRangeAddress& aLabelArea,
								const table::CellRangeAddress& aDataArea )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pOldList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();
		if (pOldList)
		{
			ScRangePairListRef xNewList(pOldList->Clone());

			ScRange aLabelRange;
			ScRange aDataRange;
			ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
			ScUnoConversion::FillScRange( aDataRange,  aDataArea );
			xNewList->Join( ScRangePair( aLabelRange, aDataRange ) );

			if (bColumn)
				pDoc->GetColNameRangesRef() = xNewList;
			else
				pDoc->GetRowNameRangesRef() = xNewList;

			pDoc->CompileColRowNameFormula();
			pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
			pDocShell->SetDocumentModified();

			//!	Undo ?!?! (hier und aus Dialog)
		}
	}
}

void SAL_CALL ScLabelRangesObj::removeByIndex( sal_Int32 nIndex )
												throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	sal_Bool bDone = sal_False;
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pOldList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();

		if ( pOldList && nIndex >= 0 && nIndex < (sal_Int32)pOldList->Count() )
		{
			ScRangePairListRef xNewList(pOldList->Clone());

			ScRangePair* pEntry = xNewList->GetObject( nIndex );
			if (pEntry)
			{
				xNewList->Remove( pEntry );
				delete pEntry;

				if (bColumn)
					pDoc->GetColNameRangesRef() = xNewList;
				else
					pDoc->GetRowNameRangesRef() = xNewList;

				pDoc->CompileColRowNameFormula();
				pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
				pDocShell->SetDocumentModified();
				bDone = sal_True;

				//!	Undo ?!?! (hier und aus Dialog)
			}
		}
	}
	if (!bDone)
		throw uno::RuntimeException();		// no other exceptions specified
}

// container::XEnumerationAccess

uno::Reference<container::XEnumeration> SAL_CALL ScLabelRangesObj::createEnumeration()
													throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
    return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.LabelRangesEnumeration")));
}

// container::XIndexAccess

sal_Int32 SAL_CALL ScLabelRangesObj::getCount() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	if (pDocShell)
	{
		ScDocument* pDoc = pDocShell->GetDocument();
		ScRangePairList* pList = bColumn ? pDoc->GetColNameRanges() : pDoc->GetRowNameRanges();
		if (pList)
			return pList->Count();
	}
	return 0;
}

uno::Any SAL_CALL ScLabelRangesObj::getByIndex( sal_Int32 nIndex )
							throw(lang::IndexOutOfBoundsException,
									lang::WrappedTargetException, uno::RuntimeException)
{
	ScUnoGuard aGuard;
	uno::Reference< sheet::XLabelRange >  xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
	if ( xRange.is() )
        return uno::makeAny(xRange);
	else
		throw lang::IndexOutOfBoundsException();
//    return uno::Any();
}

uno::Type SAL_CALL ScLabelRangesObj::getElementType() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return ::getCppuType((const uno::Reference< sheet::XLabelRange >*)0);	// muss zu getByIndex passen

}

sal_Bool SAL_CALL ScLabelRangesObj::hasElements() throw(uno::RuntimeException)
{
	ScUnoGuard aGuard;
	return ( getCount() != 0 );
}

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