| /************************************************************** |
| * |
| * 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 <stdlib.h> |
| #include <tools/rcid.h> |
| #ifndef GCC |
| #endif |
| #include <tools/stream.hxx> |
| |
| #include <sfx2/module.hxx> |
| #include <sfx2/objface.hxx> |
| #include <sfx2/msg.hxx> |
| #include <sfx2/app.hxx> |
| #include <sfx2/msgpool.hxx> |
| #include "sfx2/sfxresid.hxx" |
| #include <sfx2/minarray.hxx> |
| #include <sfx2/objsh.hxx> |
| |
| DBG_NAME(SfxInterface) |
| |
| //==================================================================== |
| |
| EXTERN_C |
| #if defined( PM2 ) && (!defined( CSET ) && !defined ( MTW ) && !defined( WTC )) |
| int _stdcall |
| #else |
| #ifdef WNT |
| int _cdecl |
| #else |
| int |
| #endif |
| #endif |
| |
| SfxCompareSlots_Impl( const void* pSmaller, const void* pBigger ) |
| { |
| DBG_MEMTEST(); |
| return ( (int) ((SfxSlot*)pSmaller)->GetSlotId() ) - |
| ( (int) ((SfxSlot*)pBigger)->GetSlotId() ); |
| } |
| |
| //========================================================================= |
| |
| struct SfxObjectUI_Impl |
| { |
| sal_uInt16 nPos; |
| ResId aResId; |
| sal_Bool bVisible; |
| sal_Bool bContext; |
| String* pName; |
| sal_uInt32 nFeature; |
| |
| SfxObjectUI_Impl(sal_uInt16 n, const ResId& rResId, sal_Bool bVis, sal_uInt32 nFeat) : |
| nPos(n), |
| aResId(rResId.GetId(), *rResId.GetResMgr()), |
| bVisible(bVis), |
| bContext(sal_False), |
| pName(0), |
| nFeature(nFeat) |
| { |
| aResId.SetRT(rResId.GetRT()); |
| } |
| |
| ~SfxObjectUI_Impl() |
| { |
| delete pName; |
| } |
| }; |
| |
| DECL_PTRARRAY(SfxObjectUIArr_Impl, SfxObjectUI_Impl*, 2, 2) |
| |
| struct SfxInterface_Impl |
| { |
| SfxObjectUIArr_Impl* pObjectBars; // registered ObjectBars |
| SfxObjectUIArr_Impl* pChildWindows; // registered ChildWindows |
| ResId aPopupRes; // registered PopupMenu |
| ResId aStatBarRes; // registered StatusBar |
| SfxModule* pModule; |
| sal_Bool bRegistered; |
| |
| SfxInterface_Impl() : |
| aPopupRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager()), |
| aStatBarRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager()) |
| , bRegistered(sal_False) |
| { |
| pObjectBars = new SfxObjectUIArr_Impl; |
| pChildWindows = new SfxObjectUIArr_Impl; |
| } |
| |
| ~SfxInterface_Impl() |
| { |
| sal_uInt16 n; |
| for (n=0; n<pObjectBars->Count(); n++) |
| delete (*pObjectBars)[n]; |
| delete pObjectBars; |
| |
| for (n=0; n<pChildWindows->Count(); n++) |
| delete (*pChildWindows)[n]; |
| delete pChildWindows; |
| } |
| }; |
| |
| static SfxObjectUI_Impl* CreateObjectBarUI_Impl( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr ); |
| |
| //==================================================================== |
| |
| //==================================================================== |
| // ctor, registeres a new unit |
| |
| SfxInterface::SfxInterface( const char *pClassName, |
| const ResId& rNameResId, |
| SfxInterfaceId nId, |
| const SfxInterface* pParent, |
| SfxSlot &rSlotMap, sal_uInt16 nSlotCount ): |
| pName(pClassName), |
| pGenoType(pParent), |
| nClassId(nId), |
| aNameResId(rNameResId.GetId(),*rNameResId.GetResMgr()), |
| pImpData(0) |
| { |
| pImpData = new SfxInterface_Impl; |
| SetSlotMap( rSlotMap, nSlotCount ); |
| } |
| |
| void SfxInterface::Register( SfxModule* pMod ) |
| { |
| pImpData->bRegistered = sal_True; |
| pImpData->pModule = pMod; |
| if ( pMod ) |
| pMod->GetSlotPool()->RegisterInterface(*this); |
| else |
| SFX_APP()->GetAppSlotPool_Impl().RegisterInterface(*this); |
| } |
| |
| void SfxInterface::SetSlotMap( SfxSlot& rSlotMap, sal_uInt16 nSlotCount ) |
| { |
| pSlots = &rSlotMap; |
| nCount = nSlotCount; |
| SfxSlot* pIter = pSlots; |
| if ( 1 == nCount && !pIter->pNextSlot ) |
| pIter->pNextSlot = pIter; |
| |
| if ( !pIter->pNextSlot ) |
| { |
| // sort the SfxSlots by id |
| qsort( pSlots, nCount, sizeof(SfxSlot), SfxCompareSlots_Impl ); |
| |
| // link masters and slaves |
| sal_uInt16 nIter = 1; |
| for ( pIter = pSlots; nIter <= nCount; ++pIter, ++nIter ) |
| { |
| //! hier bitte sinnvoll pruefen |
| //! DBG_ASSERT(!(pIter->IsMode(SFX_SLOT_CACHABLE) && |
| //! pIter->IsMode(SFX_SLOT_VOLATILE)), |
| //! "invalid Flags" ); |
| DBG_ASSERT( nIter == nCount || |
| pIter->GetSlotId() != (pIter+1)->GetSlotId(), |
| "doppelte SID" ); |
| |
| // jeder Master verweist auf seinen ersten Slave (ENUM), alle |
| // Slaves auf ihren Master. |
| // Slaves verweisen im Ring auf die anderen mit gleichem Master |
| if ( pIter->GetKind() == SFX_KIND_ENUM ) |
| { |
| pIter->pLinkedSlot = GetSlot( pIter->nMasterSlotId ); |
| DBG_ASSERT( pIter->pLinkedSlot, "slave without master" ); |
| if ( !pIter->pLinkedSlot->pLinkedSlot ) |
| ( (SfxSlot*) pIter->pLinkedSlot)->pLinkedSlot = pIter; |
| |
| if ( 0 == pIter->GetNextSlot() ) |
| { |
| SfxSlot *pLastSlot = pIter; |
| for ( sal_uInt16 n = nIter; n < Count(); ++n ) |
| { |
| SfxSlot *pCurSlot = (pSlots+n); |
| if ( pCurSlot->nMasterSlotId == pIter->nMasterSlotId ) |
| { |
| pLastSlot->pNextSlot = pCurSlot; |
| pLastSlot = pCurSlot; |
| } |
| } |
| pLastSlot->pNextSlot = pIter; |
| } |
| } |
| else if ( 0 == pIter->GetNextSlot() ) |
| { |
| // Slots verweisen im Ring auf den n"achten mit derselben Statusmethode |
| SfxSlot *pLastSlot = pIter; |
| for ( sal_uInt16 n = nIter; n < Count(); ++n ) |
| { |
| SfxSlot *pCurSlot = (pSlots+n); |
| if ( pCurSlot->GetStateFnc() == pIter->GetStateFnc() ) |
| { |
| pLastSlot->pNextSlot = pCurSlot; |
| pLastSlot = pCurSlot; |
| } |
| } |
| pLastSlot->pNextSlot = pIter; |
| } |
| } |
| } |
| #ifdef DBG_UTIL |
| else |
| { |
| sal_uInt16 nIter = 1; |
| for ( SfxSlot *pNext = pIter+1; nIter < nCount; ++pNext, ++nIter ) |
| { |
| |
| if ( pNext->GetSlotId() <= pIter->GetSlotId() ) |
| DBG_ERROR ("Falsche Reihenfolge!"); |
| |
| if ( pIter->GetKind() == SFX_KIND_ENUM ) |
| { |
| const SfxSlot *pMasterSlot = GetSlot(pIter->nMasterSlotId); |
| const SfxSlot *pFirstSlave = pMasterSlot->pLinkedSlot; |
| const SfxSlot *pSlave = pFirstSlave; |
| do |
| { |
| if ( pSlave->pLinkedSlot != pMasterSlot ) |
| { |
| ByteString aStr("Falsche Master/Slave-Verkettung : "); |
| aStr += ByteString::CreateFromInt32(pMasterSlot->GetSlotId()); |
| aStr += " , "; |
| aStr += ByteString::CreateFromInt32(pSlave->GetSlotId()); |
| DBG_ERROR(aStr.GetBuffer()); |
| } |
| |
| if ( pSlave->nMasterSlotId != pMasterSlot->GetSlotId() ) |
| { |
| ByteString aStr("Falsche Master/Slave-Ids : "); |
| aStr += ByteString::CreateFromInt32(pMasterSlot->GetSlotId()); |
| aStr += " , "; |
| aStr += ByteString::CreateFromInt32(pSlave->GetSlotId()); |
| DBG_ERROR(aStr.GetBuffer()); |
| } |
| |
| pSlave = pSlave->pNextSlot; |
| } |
| while ( pSlave != pFirstSlave ); |
| } |
| else |
| { |
| if ( pIter->pLinkedSlot ) |
| { |
| if ( pIter->pLinkedSlot->GetKind() != SFX_KIND_ENUM ) |
| { |
| ByteString aStr("Slave ist kein enum : "); |
| aStr += ByteString::CreateFromInt32(pIter->GetSlotId()); |
| aStr += " , "; |
| aStr += ByteString::CreateFromInt32(pIter->pLinkedSlot->GetSlotId()); |
| DBG_ERROR(aStr.GetBuffer()); |
| } |
| } |
| |
| const SfxSlot *pCurSlot = pIter; |
| do |
| { |
| pCurSlot = pCurSlot->pNextSlot; |
| if ( pCurSlot->GetStateFnc() != pIter->GetStateFnc() ) |
| { |
| ByteString aStr("Verkettete Slots mit verschiedenen StateMethods : "); |
| aStr += ByteString::CreateFromInt32(pCurSlot->GetSlotId()); |
| aStr += " , "; |
| aStr += ByteString::CreateFromInt32(pIter->GetSlotId()); |
| DBG_ERROR(aStr.GetBuffer()); |
| } |
| } |
| while ( pCurSlot != pIter ); |
| } |
| |
| pIter = pNext; |
| } |
| } |
| #endif |
| } |
| |
| |
| //-------------------------------------------------------------------- |
| |
| |
| |
| SfxInterface::~SfxInterface() |
| { |
| SfxModule *pMod = pImpData->pModule; |
| sal_Bool bRegistered = pImpData->bRegistered; |
| delete pImpData; |
| DBG_ASSERT( bRegistered, "Interface not registered!" ); |
| if ( bRegistered ) |
| { |
| if ( pMod ) |
| pMod->GetSlotPool()->ReleaseInterface(*this); |
| else |
| SFX_APP()->GetAppSlotPool_Impl().ReleaseInterface(*this); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| // searches for the specified func |
| |
| |
| const SfxSlot* SfxInterface::GetSlot( sal_uInt16 nFuncId ) const |
| { |
| DBG_MEMTEST(); |
| DBG_CHKTHIS(SfxInterface, 0); |
| DBG_ASSERT( this && pSlots && nCount, "" ); |
| |
| // find the id using binary search |
| void* p = bsearch( &nFuncId, pSlots, nCount, sizeof(SfxSlot), |
| SfxCompareSlots_Impl ); |
| if ( !p && pGenoType ) |
| return pGenoType->GetSlot( nFuncId ); |
| |
| return p ? (const SfxSlot*)p : 0; |
| } |
| |
| const SfxSlot* SfxInterface::GetSlot( const String& rCommand ) const |
| { |
| static const char UNO_COMMAND[] = ".uno:"; |
| |
| String aCommand( rCommand ); |
| if ( aCommand.SearchAscii( UNO_COMMAND ) == 0 ) |
| aCommand.Erase( 0, sizeof( UNO_COMMAND )-1 ); |
| |
| for ( sal_uInt16 n=0; n<nCount; n++ ) |
| { |
| if ( (pSlots+n)->pUnoName && |
| aCommand.CompareIgnoreCaseToAscii( (pSlots+n)->GetUnoName() ) == COMPARE_EQUAL ) |
| return pSlots+n; |
| } |
| |
| return pGenoType ? pGenoType->GetSlot( aCommand ) : NULL; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| const SfxSlot* SfxInterface::GetRealSlot( const SfxSlot *pSlot ) const |
| { |
| DBG_MEMTEST(); |
| DBG_CHKTHIS(SfxInterface, 0); |
| DBG_ASSERT( this && pSlots && nCount, "" ); |
| |
| if ( !ContainsSlot_Impl(pSlot) ) |
| { |
| if(pGenoType) |
| return pGenoType->GetRealSlot(pSlot); |
| DBG_ERROR("fremder Slot"); |
| return 0; |
| } |
| |
| return pSlot->pLinkedSlot; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| const SfxSlot* SfxInterface::GetRealSlot( sal_uInt16 nSlotId ) const |
| { |
| DBG_MEMTEST(); |
| DBG_CHKTHIS(SfxInterface, 0); |
| DBG_ASSERT( this && pSlots && nCount, "" ); |
| |
| const SfxSlot *pSlot = GetSlot(nSlotId); |
| if ( !pSlot ) |
| { |
| if(pGenoType) |
| return pGenoType->GetRealSlot(nSlotId); |
| DBG_ERROR("fremder Slot"); |
| return 0; |
| } |
| |
| return pSlot->pLinkedSlot; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| void SfxInterface::RegisterPopupMenu( const ResId& rResId ) |
| { |
| DBG_CHKTHIS(SfxInterface, 0); |
| pImpData->aPopupRes = rResId; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| void SfxInterface::RegisterObjectBar( sal_uInt16 nPos, const ResId& rResId, |
| const String *pStr ) |
| { |
| RegisterObjectBar( nPos, rResId, 0UL, pStr ); |
| } |
| |
| |
| void SfxInterface::RegisterObjectBar( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr ) |
| { |
| SfxObjectUI_Impl* pUI = CreateObjectBarUI_Impl( nPos, rResId, nFeature, pStr ); |
| if ( pUI ) |
| pImpData->pObjectBars->Append(pUI); |
| } |
| |
| SfxObjectUI_Impl* CreateObjectBarUI_Impl( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr ) |
| { |
| if ((nPos & SFX_VISIBILITY_MASK) == 0) |
| nPos |= SFX_VISIBILITY_STANDARD; |
| |
| SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(nPos, rResId, sal_True, nFeature); |
| |
| if (pStr == 0) |
| { |
| ResId aResId(rResId); |
| aResId.SetRT(RSC_STRING); |
| aResId.SetResMgr(rResId.GetResMgr()); |
| if( ! aResId.GetResMgr() ) |
| aResId.SetResMgr( SfxApplication::GetOrCreate()->GetOffResManager_Impl() ); |
| if ( !aResId.GetResMgr()->IsAvailable(aResId) ) |
| pUI->pName = new String (DEFINE_CONST_UNICODE("NoName")); |
| else |
| pUI->pName = new String(aResId); |
| } |
| else |
| pUI->pName = new String(*pStr); |
| |
| return pUI; |
| } |
| |
| const ResId& SfxInterface::GetObjectBarResId( sal_uInt16 nNo ) const |
| { |
| sal_Bool bGenoType = (pGenoType != 0 && !pGenoType->HasName()); |
| if ( bGenoType ) |
| { |
| // Gibt es Toolbars in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetObjectBarResId( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nObjBarCount = pImpData->pObjectBars->Count(); |
| DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" ); |
| #endif |
| return (*pImpData->pObjectBars)[nNo]->aResId; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| sal_uInt16 SfxInterface::GetObjectBarPos( sal_uInt16 nNo ) const |
| { |
| sal_Bool bGenoType = (pGenoType != 0 && !pGenoType->HasName()); |
| if ( bGenoType ) |
| { |
| // Gibt es Toolbars in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetObjectBarPos( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nObjBarCount = pImpData->pObjectBars->Count(); |
| DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" ); |
| #endif |
| return (*pImpData->pObjectBars)[nNo]->nPos; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| sal_uInt16 SfxInterface::GetObjectBarCount() const |
| { |
| if (pGenoType && ! pGenoType->HasName()) |
| return pImpData->pObjectBars->Count() + pGenoType->GetObjectBarCount(); |
| else |
| return pImpData->pObjectBars->Count(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SfxInterface::RegisterChildWindow(sal_uInt16 nId, sal_Bool bContext, const String* pChildWinName) |
| { |
| RegisterChildWindow( nId, bContext, 0UL, pChildWinName ); |
| } |
| |
| void SfxInterface::RegisterChildWindow(sal_uInt16 nId, sal_Bool bContext, sal_uInt32 nFeature, const String*) |
| { |
| SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(0, ResId(nId, *SfxApplication::GetOrCreate()->GetOffResManager_Impl()), sal_True, nFeature); |
| pUI->bContext = bContext; |
| pImpData->pChildWindows->Append(pUI); |
| } |
| |
| void SfxInterface::RegisterStatusBar(const ResId& rResId) |
| { |
| pImpData->aStatBarRes = rResId; |
| } |
| |
| |
| sal_uInt32 SfxInterface::GetChildWindowId (sal_uInt16 nNo) const |
| { |
| if ( pGenoType ) |
| { |
| // Gibt es ChildWindows in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetChildWindowId( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nCWCount = pImpData->pChildWindows->Count(); |
| DBG_ASSERT( nNo<nCWCount,"ChildWindow ist unbekannt!" ); |
| #endif |
| sal_uInt32 nRet = (*pImpData->pChildWindows)[nNo]->aResId.GetId(); |
| if ( (*pImpData->pChildWindows)[nNo]->bContext ) |
| nRet += sal_uInt32( nClassId ) << 16; |
| return nRet; |
| } |
| |
| sal_uInt32 SfxInterface::GetChildWindowFeature (sal_uInt16 nNo) const |
| { |
| if ( pGenoType ) |
| { |
| // Gibt es ChildWindows in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetChildWindowFeature( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nCWCount = pImpData->pChildWindows->Count(); |
| DBG_ASSERT( nNo<nCWCount,"ChildWindow ist unbekannt!" ); |
| #endif |
| return (*pImpData->pChildWindows)[nNo]->nFeature; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| |
| sal_uInt16 SfxInterface::GetChildWindowCount() const |
| { |
| if (pGenoType) |
| return pImpData->pChildWindows->Count() + pGenoType->GetChildWindowCount(); |
| else |
| return pImpData->pChildWindows->Count(); |
| } |
| |
| |
| const ResId& SfxInterface::GetPopupMenuResId() const |
| { |
| return pImpData->aPopupRes; |
| } |
| |
| |
| const ResId& SfxInterface::GetStatusBarResId() const |
| { |
| if (pImpData->aStatBarRes.GetId() == 0 && pGenoType) |
| return pGenoType->GetStatusBarResId(); |
| else |
| return pImpData->aStatBarRes; |
| } |
| |
| |
| |
| const String* SfxInterface::GetObjectBarName ( sal_uInt16 nNo ) const |
| { |
| sal_Bool bGenoType = (pGenoType != 0 && !pGenoType->HasName()); |
| if ( bGenoType ) |
| { |
| // Gibt es Toolbars in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetObjectBarName( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nObjBarCount = pImpData->pObjectBars->Count(); |
| DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" ); |
| #endif |
| return (*pImpData->pObjectBars)[nNo]->pName; |
| } |
| |
| sal_uInt32 SfxInterface::GetObjectBarFeature ( sal_uInt16 nNo ) const |
| { |
| sal_Bool bGenoType = (pGenoType != 0 && !pGenoType->HasName()); |
| if ( bGenoType ) |
| { |
| // Gibt es Toolbars in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->GetObjectBarFeature( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nObjBarCount = pImpData->pObjectBars->Count(); |
| DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" ); |
| #endif |
| return (*pImpData->pObjectBars)[nNo]->nFeature; |
| } |
| |
| sal_Bool SfxInterface::IsObjectBarVisible(sal_uInt16 nNo) const |
| { |
| sal_Bool bGenoType = (pGenoType != 0 && !pGenoType->HasName()); |
| if ( bGenoType ) |
| { |
| // Gibt es Toolbars in der Superklasse ? |
| sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount(); |
| if ( nNo < nBaseCount ) |
| // Die der Superklasse kommen zuerst |
| return pGenoType->IsObjectBarVisible( nNo ); |
| else |
| nNo = nNo - nBaseCount; |
| } |
| |
| #ifdef DBG_UTIL |
| sal_uInt16 nObjBarCount = pImpData->pObjectBars->Count(); |
| DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" ); |
| #endif |
| return (*pImpData->pObjectBars)[nNo]->bVisible; |
| } |
| |
| const SfxInterface* SfxInterface::GetRealInterfaceForSlot( const SfxSlot *pRealSlot ) const |
| { |
| DBG_ASSERT( pImpData->bRegistered, "Interface not registered!" ); |
| const SfxInterface* pInterface = this; |
| |
| // Der Slot k"onnte auch aus dem Interface einer Shell-Basisklasse stammen |
| do |
| { |
| const SfxSlot *pLastSlot = (*pInterface)[pInterface->Count()-1]; |
| const SfxSlot *pFirstSlot = (*pInterface)[0]; |
| |
| // Ist pInterface der Owner von pRealSlot ? |
| if ( pFirstSlot <= pRealSlot && pRealSlot <= pLastSlot ) |
| break; |
| |
| // Sonst Interface der Superklasse probieren |
| pInterface = pInterface->pGenoType; |
| } |
| while ( pInterface ); |
| |
| return pInterface; |
| } |
| |
| |
| |