xref: /aoo41x/main/sfx2/source/control/msgpool.cxx (revision d119d52d)

/**************************************************************
 *
 * 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_sfx2.hxx"
#include <tools/stream.hxx>
#include <rsc/rscsfx.hxx>
#ifndef GCC
#endif

// wg. pSlotPool
#include "appdata.hxx"
#include <sfx2/msgpool.hxx>
#include <sfx2/minarray.hxx>
#include <sfx2/msg.hxx>
#include <sfx2/app.hxx>
#include <sfx2/objface.hxx>
#include "sfxtypes.hxx"
#include "sfx2/sfxresid.hxx"
#include "arrdecl.hxx"
#include <sfx2/module.hxx>

#include <sfx2/sfx.hrc>

//====================================================================

struct SfxSIDRegistration_Impl
{
	String			_aGroup;
	String			_aName;
	sal_uInt16			_nSID;
};

struct SfxSlotType_Impl
{
	sal_uInt16  nId;
	TypeId  nType;

	SfxSlotType_Impl( sal_uInt16 nTheId, TypeId nTheType ):
		nId(nTheId), nType(nTheType)
	{}
};

DECL_2BYTEARRAY(SfxSlotGroupArr_Impl, sal_uInt16, 6, 4)
DECL_PTRARRAY(SfxInterfaceArr_Impl, SfxInterface*, 6, 3)
DECL_PTRARRAY(SfxSlotTypeArr_Impl, SfxSlotType_Impl*, 8, 8)


//====================================================================

SfxSlotPool::SfxSlotPool( SfxSlotPool *pParent, ResMgr* pResManager )
 : _pGroups(0)
 , _pTypes(0)
 , _pParentPool( pParent )
 , _pResMgr( pResManager )
 , _pInterfaces(0)
 , _nCurGroup(0)
 , _nCurInterface(0)
 , _nCurMsg(0)
 , _pUnoSlots( 0 )
{
	if ( !_pResMgr )
		_pResMgr = SfxApplication::GetOrCreate()->GetOffResManager_Impl();
}

//====================================================================

SfxSlotPool::~SfxSlotPool()
{
	_pParentPool = 0;
	for ( SfxInterface *pIF = FirstInterface(); pIF; pIF = FirstInterface() )
		delete pIF;
	delete _pInterfaces;
	delete _pGroups;
	if ( _pTypes )
	{
		for ( sal_uInt16 n =_pTypes->Count(); n--; )
			delete _pTypes->GetObject(n);
		delete _pTypes;
	}
}

//====================================================================

// registers the availability of the Interface of functions

void SfxSlotPool::RegisterInterface( SfxInterface& rInterface )
{
	DBG_MEMTEST();

	// add to the list of SfxObjectInterface instances
	if ( _pInterfaces == 0 )
		_pInterfaces = new SfxInterfaceArr_Impl;
	_pInterfaces->Append(&rInterface);

	// bei einem (einzelnen) Null-Slot abbrechen (aus syntaktischen Gr"unden
	// enthalten interfaces immer mindestens einen Slot)
	if ( rInterface.Count() == 1 && !rInterface[0]->nSlotId )
		return;

	// possibly add Interface-id and group-ids of funcs to the list of groups
	if ( !_pGroups )
	{
		_pGroups = new SfxSlotGroupArr_Impl;

		if ( _pParentPool )
		{
			// Die Groups im parent Slotpool sind auch hier bekannt
			SfxSlotGroupArr_Impl& rGroups = *_pParentPool->_pGroups;
			for ( sal_uInt16 n=0; n<rGroups.Count(); n++ )
				_pGroups->Append( rGroups[n] );
		}
	}

	if ( !_pTypes )
		_pTypes = new SfxSlotTypeArr_Impl;
	for ( sal_uInt16 nFunc = 0; nFunc < rInterface.Count(); ++nFunc )
	{
		SfxSlot *pDef = rInterface[nFunc];
		if ( pDef->GetGroupId() && /* pDef->GetGroupId() != GID_INTERN && */
			 !_pGroups->Contains(pDef->GetGroupId()) )
		{
			if (pDef->GetGroupId() == GID_INTERN)
				_pGroups->Insert(0, pDef->GetGroupId());
			else
				_pGroups->Append(pDef->GetGroupId());
		}
#if 0
		const TypeId &rTypeId = pDef->GetType()->Type();
		if ( /*rTypeId != TYPE(SfxVoidItem) &&*/ rTypeId != 0 )
		{
			sal_uInt16 nPos;
			for ( nPos = 0; nPos < _pTypes->Count(); ++nPos )
			{
				if ( _pTypes->GetObject(nPos)->nId == pDef->GetSlotId() )
				{
					DBG_ASSERT( rTypeId == _pTypes->GetObject(nPos)->nType,
								"same slot id with unequal item types" );
				}
				else if ( _pTypes->GetObject(nPos)->nId > pDef->GetSlotId() )
					break;
			}
			if ( nPos >= _pTypes->Count() ||
				 _pTypes->GetObject(nPos)->nId > pDef->GetSlotId() )
				_pTypes->Append( new SfxSlotType_Impl( pDef->GetSlotId(), rTypeId ) );
		}
#endif
	}
}

//====================================================================

TypeId SfxSlotPool::GetSlotType( sal_uInt16 nId ) const
{
	const SfxSlot* pSlot = (const_cast <SfxSlotPool*> (this))->GetSlot( nId );
	return pSlot ? pSlot->GetType()->Type() : 0;
/*
	for ( sal_uInt16 nPos = 0; nPos < _pTypes->Count(); ++nPos )
	{
		if ( _pTypes->GetObject(nPos)->nId == nId )
			return _pTypes->GetObject(nPos)->nType;
	}
	return _pParentPool ? _pParentPool->GetSlotType( nId ) : 0;
 */
}

//====================================================================

// unregisters the availability of the Interface of functions

void SfxSlotPool::ReleaseInterface( SfxInterface& rInterface )
{
	DBG_MEMTEST();
	DBG_ASSERT( _pInterfaces, "releasing SfxInterface, but there are none" );
	// remove from the list of SfxInterface instances
	_pInterfaces->Remove(&rInterface);
}

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

// get the first SfxMessage for a special Id (e.g. for getting check-mode)

const SfxSlot* SfxSlotPool::GetSlot( sal_uInt16 nId )
{
	DBG_MEMTEST();
	DBG_ASSERT( _pInterfaces != 0, "no Interfaces registered" );

	// Zun"achst die eigenen Interfaces absuchen
	for ( sal_uInt16 nInterf = 0; nInterf < _pInterfaces->Count(); ++nInterf )
	{
		const SfxSlot *pDef = _pInterfaces->GetObject(nInterf)->GetSlot(nId);
		if ( pDef )
			return pDef;
	}

	// Dann beim eventuell vorhandenen parent versuchen
	return _pParentPool ? _pParentPool->GetSlot( nId ) : 0;
}

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

// skips to the next group

String SfxSlotPool::SeekGroup( sal_uInt16 nNo )
{
	DBG_MEMTEST();
	DBG_ASSERT( _pInterfaces != 0, "no Interfaces registered" );

	// if the group exists, use it
	if ( _pGroups && nNo < _pGroups->Count() )
	{
		_nCurGroup = nNo;
		if ( _pParentPool )
		{
			// Meistens stimmt die Reihenfolge der Ids "uberein
			sal_uInt16 nParentCount = _pParentPool->_pGroups->Count();
			if ( nNo < nParentCount && (*_pGroups)[nNo] == (*_pParentPool->_pGroups)[nNo] )
				_pParentPool->_nCurGroup = nNo;
			else
			{
				// Ansonsten mu\s gesucht werden
				// Wenn die Gruppe im parent pool nicht gefunden wird, wird
				// _nCurGroup au\serhalb des g"ultigen Bereiches gesetzt
				sal_uInt16 i;
				for ( i=1; i<nParentCount; i++ )
					if ( (*_pGroups)[nNo] == (*_pParentPool->_pGroups)[i] )
						break;
				_pParentPool->_nCurGroup = i;
			}
		}

		SfxResId aResId( (*_pGroups)[_nCurGroup] );
		aResId.SetRT(RSC_STRING);
		if ( !aResId.GetResMgr()->IsAvailable(aResId) )
		{
			DBG_ERROR( "GroupId-Name nicht im SFX definiert!" );
			return String();
		}

		return String( aResId );
	}

	return String();
}


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

sal_uInt16 SfxSlotPool::GetGroupCount()
{
	return _pGroups->Count();
}


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

// internal search loop

const SfxSlot* SfxSlotPool::SeekSlot( sal_uInt16 nStartInterface )
{
	DBG_MEMTEST();
	DBG_ASSERT( _pInterfaces != 0, "no Interfaces registered" );

	// Die Numerierung der interfaces startet beim parent pool
	sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_pInterfaces->Count() : 0;

	// sind wir am Ende des Parent-Pools angekommen?
	if ( nStartInterface < nFirstInterface &&
		 _pParentPool->_nCurGroup >= _pParentPool->_pGroups->Count() )
		nStartInterface = nFirstInterface;

	// liegt das Interface noch im Parent-Pool?
	if ( nStartInterface < nFirstInterface )
	{
		DBG_ASSERT( _pParentPool, "Kein parent pool!" );
		_nCurInterface = nStartInterface;
		return _pParentPool->SeekSlot( nStartInterface );
	}

	// find the first func-def with the current group id
	sal_uInt16 nCount = _pInterfaces->Count() + nFirstInterface;
	for ( _nCurInterface = nStartInterface;
			_nCurInterface < nCount;
		  ++_nCurInterface )
	{
		SfxInterface* pInterface = (*_pInterfaces)[_nCurInterface-nFirstInterface];
		for ( _nCurMsg = 0;
			  _nCurMsg < pInterface->Count();
			  ++_nCurMsg )
		{
			const SfxSlot* pMsg = (*pInterface)[_nCurMsg];
			if ( pMsg->GetGroupId() == _pGroups->GetObject(_nCurGroup) )
				return pMsg;
		}
	}

	return 0;
}

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

// skips to the next func in the current group

const SfxSlot* SfxSlotPool::NextSlot()
{
	DBG_MEMTEST();
	DBG_ASSERT( _pInterfaces != 0, "no Interfaces registered" );

	// Die Numerierung der interfaces startet beim parent pool
	sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_pInterfaces->Count() : 0;

	if ( _nCurInterface < nFirstInterface && _nCurGroup >= _pParentPool->_pGroups->Count() )
		_nCurInterface = nFirstInterface;

	if ( _nCurInterface < nFirstInterface )
	{
		DBG_ASSERT( _pParentPool, "Kein parent pool!" );
		const SfxSlot *pSlot = _pParentPool->NextSlot();
		_nCurInterface = _pParentPool->_nCurInterface;
		if ( pSlot )
			return pSlot;
		if ( _nCurInterface == nFirstInterface )
			// parent pool ist fertig
			return SeekSlot( nFirstInterface );
	}

	sal_uInt16 nInterface = _nCurInterface - nFirstInterface;
	// possibly we are already at the end
	if ( nInterface >= _pInterfaces->Count() )
		return 0;

	// look for further matching func-defs within the same Interface
	SfxInterface* pInterface = (*_pInterfaces)[nInterface];
	while ( ++_nCurMsg < pInterface->Count() )
	{
		SfxSlot* pMsg = (*pInterface)[_nCurMsg];
		if ( pMsg->GetGroupId() == _pGroups->GetObject(_nCurGroup) )
			return pMsg;
	}

	return SeekSlot(++_nCurInterface );
}


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

// SlotName erfragen, gfs. mit HilfeText

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

SfxInterface* SfxSlotPool::FirstInterface()
{
	_nCurInterface = 0;
	if ( !_pInterfaces || !_pInterfaces->Count() )
		return 0;
	return _pParentPool ? _pParentPool->FirstInterface() : (*_pInterfaces)[0];
}


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

SfxInterface* SfxSlotPool::NextInterface()
{
	_nCurInterface++;
	sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_pInterfaces->Count() : 0;
	if ( _nCurInterface < nFirstInterface )
		return (*_pParentPool->_pInterfaces)[_nCurInterface];
	sal_uInt16 nInterface = _nCurInterface - nFirstInterface;
	return nInterface < _pInterfaces->Count() ? (*_pInterfaces)[nInterface] : 0;
}

const SfxSlot* SfxSlotPool::GetUnoSlot( const String& rName )
{
	const SfxSlot *pSlot = NULL;
    for ( sal_uInt16 nInterface=0; nInterface<_pInterfaces->Count(); nInterface++ )
    {
        pSlot = (*_pInterfaces)[nInterface]->GetSlot( rName );
        if ( pSlot )
            break;
    }

    if ( !pSlot && _pParentPool )
        pSlot = _pParentPool->GetUnoSlot( rName );

	return pSlot;
}

SfxSlotPool& SfxSlotPool::GetSlotPool( SfxViewFrame *pFrame )
{
    SfxModule *pMod = SfxModule::GetActiveModule( pFrame );
	if ( pMod && pMod->GetSlotPool() )
		return *pMod->GetSlotPool();
	else
        return *SFX_APP()->Get_Impl()->pSlotPool;
}