xref: /aoo41x/main/sd/source/ui/unoidl/unolayer.cxx (revision 79aad27f)

/**************************************************************
 *
 * 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_sd.hxx"
#include <com/sun/star/lang/DisposedException.hpp>

#include "unolayer.hxx"
#include <osl/mutex.hxx>
#include <vos/mutex.hxx>

#include <svx/svdpagv.hxx>
#include <svx/unoshape.hxx>
#include <svx/svdobj.hxx>
#include <comphelper/serviceinfohelper.hxx>

// folgende fuer InsertSdPage()
#include <svx/svdlayer.hxx>

#ifndef SVX_LIGHT
#ifndef SD_DRAW_DOC_SHELL_HXX
#include "DrawDocShell.hxx"
#endif
#endif
#include <drawdoc.hxx>
#include <unomodel.hxx>
#include "unoprnms.hxx"
#include <com/sun/star/lang/NoSupportException.hpp>
#include <svx/svdpool.hxx>
#include "unohelp.hxx"
#include "FrameView.hxx"
#include "DrawViewShell.hxx"
#include "View.hxx"
#include "ViewShell.hxx"
#include "app.hrc"
#include "strings.hrc"
#include "sdresid.hxx"
#include "glob.hrc"

#include "unokywds.hxx"
#include "unowcntr.hxx"
#include <vcl/svapp.hxx>

using namespace ::rtl;
using namespace ::vos;
using namespace ::com::sun::star;

//=============================================================================
// class SdLayer
//=============================================================================

#define WID_LAYER_LOCKED	1
#define WID_LAYER_PRINTABLE	2
#define WID_LAYER_VISIBLE	3
#define WID_LAYER_NAME		4
#define WID_LAYER_TITLE		5
#define WID_LAYER_DESC		6

const SvxItemPropertySet* ImplGetSdLayerPropertySet()
{
	static const SfxItemPropertyMapEntry aSdLayerPropertyMap_Impl[] =
	{
		{ MAP_CHAR_LEN(UNO_NAME_LAYER_LOCKED),		WID_LAYER_LOCKED,	&::getBooleanCppuType(),			0, 0 },
		{ MAP_CHAR_LEN(UNO_NAME_LAYER_PRINTABLE),	WID_LAYER_PRINTABLE,&::getBooleanCppuType(),			0, 0 },
		{ MAP_CHAR_LEN(UNO_NAME_LAYER_VISIBLE),		WID_LAYER_VISIBLE,	&::getBooleanCppuType(),			0, 0 },
		{ MAP_CHAR_LEN(UNO_NAME_LAYER_NAME),		WID_LAYER_NAME,		&::getCppuType((const OUString*)0),	0, 0 },
		{ MAP_CHAR_LEN("Title"),					WID_LAYER_TITLE,	&::getCppuType((const OUString*)0),	0, 0 },
		{ MAP_CHAR_LEN("Description"),				WID_LAYER_DESC,		&::getCppuType((const OUString*)0),	0, 0 },
		{ 0,0,0,0,0,0}
	};
    static SvxItemPropertySet aSDLayerPropertySet_Impl( aSdLayerPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
    return &aSDLayerPropertySet_Impl;
}

String SdLayer::convertToInternalName( const OUString& rName )
{
	if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_background) ) )
	{
		return String( SdResId( STR_LAYER_BCKGRND ) );
	}
	else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_background_objects) ) )
	{
		return  String( SdResId( STR_LAYER_BCKGRNDOBJ ) );
	}
	else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_layout) ) )
	{
		return  String( SdResId( STR_LAYER_LAYOUT ) );
	}
	else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_controls) ) )
	{
		return  String( SdResId( STR_LAYER_CONTROLS ) );
	}
	else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_measurelines) ) )
	{
		return  String( SdResId( STR_LAYER_MEASURELINES ) );
	}
	else
	{
		return String( rName );
	}
}

OUString SdLayer::convertToExternalName( const String& rName )
{
	const String aCompare( rName );
	if( rName == String( SdResId( STR_LAYER_BCKGRND ) ) )
	{
		return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_background) );
	}
	else if( rName == String( SdResId( STR_LAYER_BCKGRNDOBJ ) ) )
	{
		return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_background_objects) );
	}
	else if( rName == String( SdResId( STR_LAYER_LAYOUT ) ) )
	{
		return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_layout) );
	}
	else if( rName == String( SdResId( STR_LAYER_CONTROLS ) ) )
	{
		return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_controls) );
	}
	else if( rName == String( SdResId( STR_LAYER_MEASURELINES ) ) )
	{
		return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_measurelines) );
	}
	else
	{
		return OUString( rName );
	}
}

/** */
SdLayer::SdLayer( SdLayerManager* pLayerManager_, SdrLayer* pSdrLayer_ ) throw()
: pLayerManager(pLayerManager_)
, mxLayerManager(pLayerManager_)
, pLayer(pSdrLayer_)
, pPropSet(ImplGetSdLayerPropertySet())
{
}

/** */
SdLayer::~SdLayer() throw()
{
}

// uno helper
UNO3_GETIMPLEMENTATION_IMPL( SdLayer );

// XServiceInfo
OUString SAL_CALL SdLayer::getImplementationName()
	throw(uno::RuntimeException)
{
	return OUString( OUString::createFromAscii(sUNO_SdLayer) );
}

sal_Bool SAL_CALL SdLayer::supportsService( const OUString& ServiceName )
	throw(uno::RuntimeException)
{
	return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
}

uno::Sequence< OUString > SAL_CALL SdLayer::getSupportedServiceNames()
	throw(uno::RuntimeException)
{
	OUString aServiceName( OUString::createFromAscii(sUNO_Service_DrawingLayer) );
	uno::Sequence< OUString > aSeq( &aServiceName, 1 );
	return aSeq;
}

// beans::XPropertySet
uno::Reference< beans::XPropertySetInfo > SAL_CALL SdLayer::getPropertySetInfo(  )
	throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	return pPropSet->getPropertySetInfo();
}

void SAL_CALL SdLayer::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
	throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if(pLayer == NULL || pLayerManager == NULL)
		throw lang::DisposedException();

	const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(aPropertyName);

	switch( pEntry ? pEntry->nWID : -1 )
	{
	case WID_LAYER_LOCKED:
	{
		sal_Bool bValue = sal_False;
		if(!sd::any2bool( aValue, bValue ))
			throw lang::IllegalArgumentException();
		set( LOCKED, bValue );
		break;
	}
	case WID_LAYER_PRINTABLE:
	{
		sal_Bool bValue = sal_False;
		if(!sd::any2bool( aValue, bValue ))
			throw lang::IllegalArgumentException();
		set( PRINTABLE, bValue );
		break;
	}
	case WID_LAYER_VISIBLE:
	{
		sal_Bool bValue = sal_False;
		if(!sd::any2bool( aValue, bValue ))
			throw lang::IllegalArgumentException();
		set( VISIBLE, bValue );
		break;
	}
	case WID_LAYER_NAME:
	{
		OUString aName;
		if(!(aValue >>= aName))
			throw lang::IllegalArgumentException();

		pLayer->SetName(SdLayer::convertToInternalName( aName ) );
		pLayerManager->UpdateLayerView();
		break;
	}

	case WID_LAYER_TITLE:
	{
		OUString sTitle;
		if(!(aValue >>= sTitle))
			throw lang::IllegalArgumentException();

		pLayer->SetTitle(sTitle);
		break;
	}

	case WID_LAYER_DESC:
	{
		OUString sDescription;
		if(!(aValue >>= sDescription))
			throw lang::IllegalArgumentException();

		pLayer->SetDescription(sDescription);
		break;
	}

	default:
		throw beans::UnknownPropertyException();
	}

#ifndef SVX_LIGHT
	if(	pLayerManager->GetDocShell() )
		pLayerManager->GetDocShell()->SetModified();
#endif
}

uno::Any SAL_CALL SdLayer::getPropertyValue( const OUString& PropertyName )
	throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if(pLayer == NULL || pLayerManager == NULL)
		throw lang::DisposedException();

	const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(PropertyName);

	uno::Any aValue;

	switch( pEntry ? pEntry->nWID : -1 )
	{
	case WID_LAYER_LOCKED:
		sd::bool2any( get( LOCKED ), aValue );
		break;
	case WID_LAYER_PRINTABLE:
		sd::bool2any( get( PRINTABLE ), aValue );
		break;
	case WID_LAYER_VISIBLE:
		sd::bool2any( get( VISIBLE ), aValue );
		break;
	case WID_LAYER_NAME:
	{
		OUString aRet( SdLayer::convertToExternalName( pLayer->GetName() ) );
		aValue <<= aRet;
		break;
	}
	case WID_LAYER_TITLE:
		aValue <<= OUString( pLayer->GetTitle() );
		break;
	case WID_LAYER_DESC:
		aValue <<= OUString( pLayer->GetDescription() );
		break;
	default:
		throw beans::UnknownPropertyException();
	}

	return aValue;
}

void SAL_CALL SdLayer::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
void SAL_CALL SdLayer::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
void SAL_CALL SdLayer::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
void SAL_CALL SdLayer::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}

/** */
sal_Bool SdLayer::get( LayerAttribute what ) throw()
{
	if(pLayer&&pLayerManager)
	{
		// Versuch 1. ist eine beliebige Seite geoeffnet?
		::sd::View *pView = pLayerManager->GetView();
		SdrPageView* pSdrPageView = NULL;
		if(pView)
			pSdrPageView = pView->GetSdrPageView();

		if(pSdrPageView)
		{
			String aLayerName = pLayer->GetName();
			switch(what)
			{
			case VISIBLE:	return pSdrPageView->IsLayerVisible(aLayerName);
			case PRINTABLE:	return pSdrPageView->IsLayerPrintable(aLayerName);
			case LOCKED:   	return pSdrPageView->IsLayerLocked(aLayerName);
			}
		}

#ifndef SVX_LIGHT
		// Versuch 2. Info von der FrameView besorgen
		if(pLayerManager->GetDocShell())
		{
			::sd::FrameView *pFrameView = pLayerManager->GetDocShell()->GetFrameView();
			if(pFrameView)
				switch(what)
				{
				case VISIBLE:	return pFrameView->GetVisibleLayers().IsSet(pLayer->GetID());
				case PRINTABLE:	return pFrameView->GetPrintableLayers().IsSet(pLayer->GetID());
				case LOCKED:	return pFrameView->GetLockedLayers().IsSet(pLayer->GetID());
				}
		}
#endif
	}
	return sal_False; //TODO: uno::Exception?
}

void SdLayer::set( LayerAttribute what, sal_Bool flag ) throw()
{
	if(pLayer&&pLayerManager)
	{
		// Versuch 1. ist eine beliebige Seite geoeffnet?
		::sd::View *pView = pLayerManager->GetView();
		SdrPageView* pSdrPageView = NULL;
		if(pView)
			pSdrPageView = pView->GetSdrPageView();

		if(pSdrPageView)
		{
			String aLayerName(pLayer->GetName());
			switch(what)
			{
			case VISIBLE:	pSdrPageView->SetLayerVisible(aLayerName,flag);
							break;
			case PRINTABLE:	pSdrPageView->SetLayerPrintable(aLayerName,flag);
							break;
			case LOCKED:	pSdrPageView->SetLayerLocked(aLayerName,flag);
							break;
			}
		}

#ifndef SVX_LIGHT
		// Versuch 2. Info von der FrameView besorgen
		if(pLayerManager->GetDocShell())
		{
			::sd::FrameView *pFrameView = pLayerManager->GetDocShell()->GetFrameView();

			if(pFrameView)
			{
				SetOfByte aNewLayers;
				switch(what)
				{
				case VISIBLE:	aNewLayers = pFrameView->GetVisibleLayers();
								break;
				case PRINTABLE:	aNewLayers = pFrameView->GetPrintableLayers();
								break;
				case LOCKED:	aNewLayers = pFrameView->GetLockedLayers();
								break;
				}

				aNewLayers.Set(pLayer->GetID(),flag);

				switch(what)
				{
				case VISIBLE:	pFrameView->SetVisibleLayers(aNewLayers);
								break;
				case PRINTABLE:	pFrameView->SetPrintableLayers(aNewLayers);
								break;
				case LOCKED:	pFrameView->SetLockedLayers(aNewLayers);
								break;
				}
				return;
			}
		}
#endif
	}
	//TODO: uno::Exception?
}




//=====  ::com::sun::star::container::XChild  =================================

uno::Reference<uno::XInterface> SAL_CALL SdLayer::getParent (void)
    throw (::com::sun::star::uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( pLayerManager == NULL )
		throw lang::DisposedException();

    return uno::Reference<uno::XInterface> (mxLayerManager, uno::UNO_QUERY);
}


void SAL_CALL SdLayer::setParent (const uno::Reference<uno::XInterface >& )
    throw (::com::sun::star::lang::NoSupportException,
        ::com::sun::star::uno::RuntimeException)
{
    throw lang::NoSupportException ();
}

// XComponent
void SAL_CALL SdLayer::dispose(  ) throw (uno::RuntimeException)
{
	pLayerManager = 0;
	mxLayerManager = 0;
	pLayer = 0;
}

void SAL_CALL SdLayer::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
{
	DBG_ERROR("not implemented!");
}

void SAL_CALL SdLayer::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
{
	DBG_ERROR("not implemented!");
}


//=============================================================================
// class SdLayerManager
//=============================================================================

/** */
SdLayerManager::SdLayerManager( SdXImpressDocument& rMyModel ) throw()
:mpModel( &rMyModel)
{
	mpLayers = new SvUnoWeakContainer;
}

/** */
SdLayerManager::~SdLayerManager() throw()
{
    dispose();
}

// uno helper
UNO3_GETIMPLEMENTATION_IMPL( SdLayerManager );

// XComponent
void SAL_CALL SdLayerManager::dispose(  ) throw (uno::RuntimeException)
{
	mpModel = 0;
	if( mpLayers )
	{
		mpLayers->dispose();

		delete mpLayers;
		mpLayers = 0;
	}
}

void SAL_CALL SdLayerManager::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
{
	DBG_ERROR("not implemented!");
}

void SAL_CALL SdLayerManager::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
{
	DBG_ERROR("not implemented!");
}

// XServiceInfo
OUString SAL_CALL SdLayerManager::getImplementationName()
	throw(uno::RuntimeException)
{
	return OUString( OUString::createFromAscii(sUNO_SdLayerManager) );
}

sal_Bool SAL_CALL SdLayerManager::supportsService( const OUString& ServiceName )
	throw(uno::RuntimeException)
{
	return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
}

uno::Sequence< OUString > SAL_CALL SdLayerManager::getSupportedServiceNames()
	throw(uno::RuntimeException)
{
	OUString aServiceName( OUString::createFromAscii(sUNO_Service_DrawingLayerManager) );
	uno::Sequence< OUString > aSeq( &aServiceName, 1 );
	return aSeq;
}

// XLayerManager
uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::insertNewByIndex( sal_Int32 nIndex )
	throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	uno::Reference< drawing::XLayer > xLayer;

	if( mpModel->mpDoc )
	{
		SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
		sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
		sal_uInt16 nLayer = nLayerCnt - 2 + 1;
		String aLayerName;

		// Ueberpruefung auf schon vorhandene Namen
		while( aLayerName.Len()==0 || rLayerAdmin.GetLayer( aLayerName, sal_False) )
		{
			aLayerName = String(SdResId(STR_LAYER));
			aLayerName += String::CreateFromInt32( (sal_Int32)nLayer );
			nLayer++;
		}

		SdrLayerAdmin& rLA=mpModel->mpDoc->GetLayerAdmin();
		const sal_Int32 nMax=rLA.GetLayerCount();
		if (nIndex>nMax) nIndex=nMax;
		xLayer = GetLayer (rLA.NewLayer(aLayerName,(sal_uInt16)nIndex));
		mpModel->SetModified();
	}
	return xLayer;
}

void SAL_CALL SdLayerManager::remove( const uno::Reference< drawing::XLayer >& xLayer )
	throw(container::NoSuchElementException, uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);

	if(pSdLayer && GetView())
	{
		const SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer();
		GetView()->DeleteLayer( pSdrLayer->GetName() );

		UpdateLayerView();
	}

	mpModel->SetModified();
}

void SAL_CALL SdLayerManager::attachShapeToLayer( const uno::Reference< drawing::XShape >& xShape, const uno::Reference< drawing::XLayer >& xLayer )
	throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);
	SdrLayer* pSdrLayer = pSdLayer?pSdLayer->GetSdrLayer():NULL;
	if(pSdrLayer==NULL)
		return;

	SvxShape* pShape = SvxShape::getImplementation( xShape );
	SdrObject* pSdrObject = pShape?pShape->GetSdrObject():NULL;

	if(pSdrObject && pSdrLayer )
		pSdrObject->SetLayer(pSdrLayer->GetID());

	mpModel->SetModified();
}

uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::getLayerForShape( const uno::Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	uno::Reference< drawing::XLayer >  xLayer;

	if(mpModel->mpDoc)
	{
		SvxShape* pShape = SvxShape::getImplementation( xShape );
		SdrObject* pObj = pShape?pShape->GetSdrObject():NULL;
		if(pObj)
		{
			SdrLayerID aId = pObj->GetLayer();
			SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
			xLayer = GetLayer (rLayerAdmin.GetLayerPerID(aId));
		}
	}
	return xLayer;
}

// XIndexAccess
sal_Int32 SAL_CALL SdLayerManager::getCount()
	throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	if( mpModel->mpDoc )
	{
		SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
		return rLayerAdmin.GetLayerCount();
	}

	return 0;
}

uno::Any SAL_CALL SdLayerManager::getByIndex( sal_Int32 nLayer )
	throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	if( nLayer >= getCount() || nLayer < 0 )
		throw lang::IndexOutOfBoundsException();

	uno::Any aAny;

	if( mpModel->mpDoc )
	{
		SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
		uno::Reference<drawing::XLayer> xLayer (GetLayer (rLayerAdmin.GetLayer((sal_uInt16)nLayer)));
		aAny <<= xLayer;
	}
	return aAny;
}


// XNameAccess
uno::Any SAL_CALL SdLayerManager::getByName( const OUString& aName )
	throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpModel == 0) || (mpModel->mpDoc == 0 ) )
		throw lang::DisposedException();

	SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
	SdrLayer* pLayer = rLayerAdmin.GetLayer( SdLayer::convertToInternalName( aName ), sal_False );
	if( pLayer == NULL )
		throw container::NoSuchElementException();

	return uno::Any( GetLayer (pLayer) );
}

uno::Sequence< OUString > SAL_CALL SdLayerManager::getElementNames()
	throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
	const sal_uInt16 nLayerCount = rLayerAdmin.GetLayerCount();

	uno::Sequence< OUString > aSeq( nLayerCount );

	OUString* pStrings = aSeq.getArray();
	SdrLayer* pLayer;

	for( sal_uInt16 nLayer = 0; nLayer < nLayerCount; nLayer++ )
	{
		pLayer = rLayerAdmin.GetLayer( nLayer );
		if( pLayer )
			*pStrings++ = SdLayer::convertToExternalName( pLayer->GetName() );
	}

	return aSeq;
}

sal_Bool SAL_CALL SdLayerManager::hasByName( const OUString& aName ) throw(uno::RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( mpModel == 0 )
		throw lang::DisposedException();

	SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();

	return NULL != rLayerAdmin.GetLayer( SdLayer::convertToInternalName( aName ), sal_False );
}

// XElementAccess
uno::Type SAL_CALL SdLayerManager::getElementType()
	throw(uno::RuntimeException)
{
	return ITYPE( drawing::XLayer );
}

sal_Bool SAL_CALL SdLayerManager::hasElements() throw(uno::RuntimeException)
{
	return getCount() > 0;
}

/** Falls an den Layern was geaendert wurde sorgt diese Methode dafuer, das
	die Aenderungen auch in der sdbcx::View sichtbar gemacht werden */
void SdLayerManager::UpdateLayerView( sal_Bool modify ) const throw()
{
	if(mpModel->mpDocShell)
	{
		::sd::DrawViewShell* pDrViewSh =
			PTR_CAST(::sd::DrawViewShell, mpModel->mpDocShell->GetViewShell());

		if(pDrViewSh)
		{
			sal_Bool bLayerMode = pDrViewSh->IsLayerModeActive();
			pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), !bLayerMode);
			pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), bLayerMode);
		}

		if(modify)
			mpModel->mpDoc->SetChanged(sal_True);
	}
}

/** */
::sd::View* SdLayerManager::GetView() const throw()
{
	if( mpModel->mpDocShell )
	{
		::sd::ViewShell* pViewSh = mpModel->mpDocShell->GetViewShell();
		if(pViewSh)
			return pViewSh->GetView();
	}
	return NULL;
}



namespace
{
/** Compare two pointers to <type>SdrLayer</type> objects.
    @param xRef
        The implementing SdLayer class provides the first pointer by the
        <member>SdLayer::GetSdrLayer</member> method.
    @param pSearchData
        This void pointer is the second pointer to an <type>SdrLayer</type>
        object.
    @return
        Return </True> if both pointers point to the same object.
*/
sal_Bool compare_layers (uno::WeakReference<uno::XInterface> xRef, void* pSearchData)
{
	uno::Reference<uno::XInterface> xLayer (xRef);
	if (xLayer.is())
	{
        SdLayer* pSdLayer = SdLayer::getImplementation (xRef);
        if (pSdLayer != NULL)
        {
            SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer ();
            if (pSdrLayer == static_cast<SdrLayer*>(pSearchData))
                return sal_True;
        }
	}
	return sal_False;
}
}

/** Use the <member>mpLayers</member> container of weak references to either
    retrieve and return a previously created <type>XLayer</type> object for
    the given <type>SdrLayer</type> object or create and remember a new one.
*/
uno::Reference<drawing::XLayer> SdLayerManager::GetLayer (SdrLayer* pLayer)
{
	uno::WeakReference<uno::XInterface> xRef;
	uno::Reference<drawing::XLayer>  xLayer;

    // Search existing xLayer for the given pLayer.
	if (mpLayers->findRef (xRef, (void*)pLayer, compare_layers))
        xLayer = uno::Reference<drawing::XLayer> (xRef, uno::UNO_QUERY);

    // Create the xLayer if necessary.
	if ( ! xLayer.is())
	{
		xLayer = new SdLayer (this, pLayer);

        // Remember the new xLayer for future calls.
        uno::WeakReference<uno::XInterface> wRef(xLayer);
        mpLayers->insert(wRef);
	}

    return xLayer;
}