sfx2/source/control/objface.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: objface.cxx,v $
  10  * $Revision: 1.21 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sfx2.hxx"
  33
  34 #include <stdlib.h>
  35 #include <tools/rcid.h>
  36 #ifndef GCC
  37 #endif
  38 #include <tools/stream.hxx>
  39
  40 #include <sfx2/module.hxx>
  41 #include <sfx2/objface.hxx>
  42 #include <sfx2/msg.hxx>
  43 #include <sfx2/app.hxx>
  44 #include <sfx2/msgpool.hxx>
  45 #include "sfxresid.hxx"
  46 #include <sfx2/minarray.hxx>
  47 #include <sfx2/objsh.hxx>
  48
  49 DBG_NAME(SfxInterface)
  50
  51 //====================================================================
  52
  53 EXTERN_C
  54 #if defined( PM2 ) && (!defined( CSET ) && !defined ( MTW ) && !defined( WTC ))
  55 int _stdcall
  56 #else
  57 #ifdef WNT
  58 int _cdecl
  59 #else
  60 int
  61 #endif
  62 #endif
  63
  64 SfxCompareSlots_Impl( const void* pSmaller, const void* pBigger )
  65 {
  66     DBG_MEMTEST();
  67     return ( (int) ((SfxSlot*)pSmaller)->GetSlotId() ) -
  68            ( (int) ((SfxSlot*)pBigger)->GetSlotId() );
  69 }
  70
  71 //=========================================================================
  72
  73 struct SfxObjectUI_Impl
  74 {
  75     USHORT      nPos;
  76     ResId       aResId;
  77     BOOL        bVisible;
  78     BOOL        bContext;
  79     String* pName;
  80     sal_uInt32  nFeature;
  81
  82     SfxObjectUI_Impl(USHORT n, const ResId& rResId, BOOL bVis, sal_uInt32 nFeat) :
  83         nPos(n),
  84         aResId(rResId.GetId(), *rResId.GetResMgr()),
  85         bVisible(bVis),
  86         bContext(FALSE),
  87         pName(0),
  88         nFeature(nFeat)
  89     {
  90         aResId.SetRT(rResId.GetRT());
  91     }
  92
  93     ~SfxObjectUI_Impl()
  94     {
  95         delete pName;
  96     }
  97 };
  98
  99 DECL_PTRARRAY(SfxObjectUIArr_Impl, SfxObjectUI_Impl*, 2, 2)
 100
 101 struct SfxInterface_Impl
 102 {
 103     SfxObjectUIArr_Impl*        pObjectBars;    // registered ObjectBars
 104     SfxObjectUIArr_Impl*        pChildWindows;  // registered ChildWindows
 105     ResId                                       aPopupRes;              // registered PopupMenu
 106     ResId                                       aStatBarRes;    // registered StatusBar
 107     SfxModule*                          pModule;
 108     BOOL                    bRegistered;
 109
 110     SfxInterface_Impl() :
 111         aPopupRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager()),
 112         aStatBarRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager())
 113     , bRegistered(FALSE)
 114     {
 115         pObjectBars   = new SfxObjectUIArr_Impl;
 116         pChildWindows = new SfxObjectUIArr_Impl;
 117     }
 118
 119     ~SfxInterface_Impl()
 120     {
 121         USHORT n;
 122         for (n=0; n<pObjectBars->Count(); n++)
 123             delete (*pObjectBars)[n];
 124         delete pObjectBars;
 125
 126         for (n=0; n<pChildWindows->Count(); n++)
 127             delete (*pChildWindows)[n];
 128         delete pChildWindows;
 129     }
 130 };
 131
 132 static SfxObjectUI_Impl* CreateObjectBarUI_Impl( USHORT nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr );
 133
 134 //====================================================================
 135
 136 //====================================================================
 137 // ctor, registeres a new unit
 138
 139 SfxInterface::SfxInterface( const char *pClassName,
 140                             const ResId& rNameResId,
 141                             SfxInterfaceId nId,
 142                             const SfxInterface* pParent,
 143                             SfxSlot &rSlotMap, USHORT nSlotCount ):
 144     pName(pClassName),
 145     pGenoType(pParent),
 146     nClassId(nId),
 147     aNameResId(rNameResId.GetId(),*rNameResId.GetResMgr()),
 148     pImpData(0)
 149 {
 150     pImpData = new SfxInterface_Impl;
 151     SetSlotMap( rSlotMap, nSlotCount );
 152 }
 153
 154 void SfxInterface::Register( SfxModule* pMod )
 155 {
 156     pImpData->bRegistered = TRUE;
 157     pImpData->pModule = pMod;
 158     if ( pMod )
 159         pMod->GetSlotPool()->RegisterInterface(*this);
 160     else
 161         SFX_APP()->GetAppSlotPool_Impl().RegisterInterface(*this);
 162 }
 163
 164 void SfxInterface::SetSlotMap( SfxSlot& rSlotMap, USHORT nSlotCount )
 165 {
 166     pSlots = &rSlotMap;
 167     nCount = nSlotCount;
 168     SfxSlot* pIter = pSlots;
 169     if ( 1 == nCount && !pIter->pNextSlot )
 170         pIter->pNextSlot = pIter;
 171
 172     if ( !pIter->pNextSlot )
 173     {
 174         // sort the SfxSlots by id
 175         qsort( pSlots, nCount, sizeof(SfxSlot), SfxCompareSlots_Impl );
 176
 177         // link masters and slaves
 178         USHORT nIter = 1;
 179         for ( pIter = pSlots; nIter <= nCount; ++pIter, ++nIter )
 180         {
 181             //! hier bitte sinnvoll pruefen
 182             //! DBG_ASSERT(!(pIter->IsMode(SFX_SLOT_CACHABLE) &&
 183             //!                 pIter->IsMode(SFX_SLOT_VOLATILE)),
 184             //!             "invalid Flags" );
 185             DBG_ASSERT( nIter == nCount ||
 186                         pIter->GetSlotId() != (pIter+1)->GetSlotId(),
 187                         "doppelte SID" );
 188
 189             // jeder Master verweist auf seinen ersten Slave (ENUM), alle
 190             // Slaves auf ihren Master.
 191             // Slaves verweisen im Ring auf die anderen mit gleichem Master
 192             if ( pIter->GetKind() == SFX_KIND_ENUM )
 193             {
 194                 pIter->pLinkedSlot = GetSlot( pIter->nMasterSlotId );
 195                 DBG_ASSERT( pIter->pLinkedSlot, "slave without master" );
 196                 if ( !pIter->pLinkedSlot->pLinkedSlot )
 197                     ( (SfxSlot*) pIter->pLinkedSlot)->pLinkedSlot = pIter;
 198
 199                 if ( 0 == pIter->GetNextSlot() )
 200                 {
 201                     SfxSlot *pLastSlot = pIter;
 202                     for ( USHORT n = nIter; n < Count(); ++n )
 203                     {
 204                         SfxSlot *pCurSlot = (pSlots+n);
 205                         if ( pCurSlot->nMasterSlotId == pIter->nMasterSlotId )
 206                         {
 207                             pLastSlot->pNextSlot = pCurSlot;
 208                             pLastSlot = pCurSlot;
 209                         }
 210                     }
 211                     pLastSlot->pNextSlot = pIter;
 212                 }
 213             }
 214             else if ( 0 == pIter->GetNextSlot() )
 215             {
 216                 // Slots verweisen im Ring auf den n"achten mit derselben Statusmethode
 217                 SfxSlot *pLastSlot = pIter;
 218                 for ( USHORT n = nIter; n < Count(); ++n )
 219                 {
 220                     SfxSlot *pCurSlot = (pSlots+n);
 221                     if ( pCurSlot->GetStateFnc() == pIter->GetStateFnc() )
 222                     {
 223                         pLastSlot->pNextSlot = pCurSlot;
 224                         pLastSlot = pCurSlot;
 225                     }
 226                 }
 227                 pLastSlot->pNextSlot = pIter;
 228             }
 229         }
 230     }
 231 #ifdef DBG_UTIL
 232     else
 233     {
 234         USHORT nIter = 1;
 235         for ( SfxSlot *pNext = pIter+1; nIter < nCount; ++pNext, ++nIter )
 236         {
 237
 238             if ( pNext->GetSlotId() <= pIter->GetSlotId() )
 239                 DBG_ERROR ("Falsche Reihenfolge!");
 240
 241             if ( pIter->GetKind() == SFX_KIND_ENUM )
 242             {
 243                 const SfxSlot *pMasterSlot = GetSlot(pIter->nMasterSlotId);
 244                 const SfxSlot *pFirstSlave = pMasterSlot->pLinkedSlot;
 245                 const SfxSlot *pSlave = pFirstSlave;
 246                 do
 247                 {
 248                     if ( pSlave->pLinkedSlot != pMasterSlot )
 249                     {
 250                         ByteString aStr("Falsche Master/Slave-Verkettung : ");
 251                         aStr += ByteString::CreateFromInt32(pMasterSlot->GetSlotId());
 252                         aStr += " , ";
 253                         aStr += ByteString::CreateFromInt32(pSlave->GetSlotId());
 254                         DBG_ERROR(aStr.GetBuffer());
 255                     }
 256
 257                     if ( pSlave->nMasterSlotId != pMasterSlot->GetSlotId() )
 258                     {
 259                         ByteString aStr("Falsche Master/Slave-Ids : ");
 260                         aStr += ByteString::CreateFromInt32(pMasterSlot->GetSlotId());
 261                         aStr += " , ";
 262                         aStr += ByteString::CreateFromInt32(pSlave->GetSlotId());
 263                         DBG_ERROR(aStr.GetBuffer());
 264                     }
 265
 266                     pSlave = pSlave->pNextSlot;
 267                 }
 268                 while ( pSlave != pFirstSlave );
 269             }
 270             else
 271             {
 272                 if ( pIter->pLinkedSlot )
 273                 {
 274                     if ( pIter->pLinkedSlot->GetKind() != SFX_KIND_ENUM )
 275                     {
 276                         ByteString aStr("Slave ist kein enum : ");
 277                         aStr += ByteString::CreateFromInt32(pIter->GetSlotId());
 278                         aStr += " , ";
 279                         aStr += ByteString::CreateFromInt32(pIter->pLinkedSlot->GetSlotId());
 280                         DBG_ERROR(aStr.GetBuffer());
 281                     }
 282                 }
 283
 284                 const SfxSlot *pCurSlot = pIter;
 285                 do
 286                 {
 287                     pCurSlot = pCurSlot->pNextSlot;
 288                     if ( pCurSlot->GetStateFnc() != pIter->GetStateFnc() )
 289                     {
 290                         ByteString aStr("Verkettete Slots mit verschiedenen StateMethods : ");
 291                         aStr += ByteString::CreateFromInt32(pCurSlot->GetSlotId());
 292                         aStr += " , ";
 293                         aStr += ByteString::CreateFromInt32(pIter->GetSlotId());
 294                         DBG_ERROR(aStr.GetBuffer());
 295                     }
 296                 }
 297                 while ( pCurSlot != pIter );
 298             }
 299
 300             pIter = pNext;
 301         }
 302     }
 303 #endif
 304 }
 305
 306
 307 //--------------------------------------------------------------------
 308
 309
 310
 311 SfxInterface::~SfxInterface()
 312 {
 313     SfxModule *pMod = pImpData->pModule;
 314     BOOL bRegistered = pImpData->bRegistered;
 315     delete pImpData;
 316     DBG_ASSERT( bRegistered, "Interface not registered!" );
 317     if ( bRegistered )
 318     {
 319         if ( pMod )
 320             pMod->GetSlotPool()->ReleaseInterface(*this);
 321         else
 322             SFX_APP()->GetAppSlotPool_Impl().ReleaseInterface(*this);
 323     }
 324 }
 325
 326 //--------------------------------------------------------------------
 327
 328 // searches for the specified func
 329
 330
 331 const SfxSlot* SfxInterface::GetSlot( USHORT nFuncId ) const
 332 {
 333     DBG_MEMTEST();
 334     DBG_CHKTHIS(SfxInterface, 0);
 335     DBG_ASSERT( this && pSlots && nCount, "" );
 336
 337     // find the id using binary search
 338     void* p = bsearch( &nFuncId, pSlots, nCount, sizeof(SfxSlot),
 339                        SfxCompareSlots_Impl );
 340     if ( !p && pGenoType )
 341         return pGenoType->GetSlot( nFuncId );
 342
 343     return p ? (const SfxSlot*)p : 0;
 344 }
 345
 346 const SfxSlot* SfxInterface::GetSlot( const String& rCommand ) const
 347 {
 348     static const char UNO_COMMAND[] = ".uno:";
 349
 350     String aCommand( rCommand );
 351     if ( aCommand.SearchAscii( UNO_COMMAND ) == 0 )
 352          aCommand.Erase( 0, sizeof( UNO_COMMAND )-1 );
 353
 354     for ( USHORT n=0; n<nCount; n++ )
 355     {
 356         if ( (pSlots+n)->pUnoName &&
 357              aCommand.CompareIgnoreCaseToAscii( (pSlots+n)->GetUnoName() ) == COMPARE_EQUAL )
 358             return pSlots+n;
 359     }
 360
 361     return pGenoType ? pGenoType->GetSlot( aCommand ) : NULL;
 362 }
 363
 364 //--------------------------------------------------------------------
 365
 366
 367 const SfxSlot* SfxInterface::GetRealSlot( const SfxSlot *pSlot ) const
 368 {
 369     DBG_MEMTEST();
 370     DBG_CHKTHIS(SfxInterface, 0);
 371     DBG_ASSERT( this && pSlots && nCount, "" );
 372
 373     if ( !ContainsSlot_Impl(pSlot) )
 374     {
 375         if(pGenoType)
 376             return pGenoType->GetRealSlot(pSlot);
 377         DBG_ERROR("fremder Slot");
 378         return 0;
 379     }
 380
 381     return pSlot->pLinkedSlot;
 382 }
 383
 384 //--------------------------------------------------------------------
 385
 386
 387 const SfxSlot* SfxInterface::GetRealSlot( USHORT nSlotId ) const
 388 {
 389     DBG_MEMTEST();
 390     DBG_CHKTHIS(SfxInterface, 0);
 391     DBG_ASSERT( this && pSlots && nCount, "" );
 392
 393     const SfxSlot *pSlot = GetSlot(nSlotId);
 394     if ( !pSlot )
 395     {
 396         if(pGenoType)
 397             return pGenoType->GetRealSlot(nSlotId);
 398         DBG_ERROR("fremder Slot");
 399         return 0;
 400     }
 401
 402     return pSlot->pLinkedSlot;
 403 }
 404
 405 //--------------------------------------------------------------------
 406
 407
 408 void SfxInterface::RegisterPopupMenu( const ResId& rResId )
 409 {
 410     DBG_CHKTHIS(SfxInterface, 0);
 411     pImpData->aPopupRes = rResId;
 412 }
 413
 414 //--------------------------------------------------------------------
 415
 416 void SfxInterface::RegisterObjectBar( USHORT nPos, const ResId& rResId,
 417         const String *pStr )
 418 {
 419     RegisterObjectBar( nPos, rResId, 0UL, pStr );
 420 }
 421
 422
 423 void SfxInterface::RegisterObjectBar( USHORT nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr )
 424 {
 425     SfxObjectUI_Impl* pUI = CreateObjectBarUI_Impl( nPos, rResId, nFeature, pStr );
 426     if ( pUI )
 427         pImpData->pObjectBars->Append(pUI);
 428 }
 429
 430 SfxObjectUI_Impl* CreateObjectBarUI_Impl( USHORT nPos, const ResId& rResId, sal_uInt32 nFeature, const String *pStr )
 431 {
 432     if ((nPos & SFX_VISIBILITY_MASK) == 0)
 433         nPos |= SFX_VISIBILITY_STANDARD;
 434
 435     SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(nPos, rResId, TRUE, nFeature);
 436
 437     if (pStr == 0)
 438     {
 439         ResId aResId(rResId);
 440         aResId.SetRT(RSC_STRING);
 441         aResId.SetResMgr(rResId.GetResMgr());
 442         if( ! aResId.GetResMgr() )
 443             aResId.SetResMgr( SfxApplication::GetOrCreate()->GetOffResManager_Impl() );
 444         if ( !aResId.GetResMgr()->IsAvailable(aResId) )
 445             pUI->pName = new String (DEFINE_CONST_UNICODE("NoName"));
 446         else
 447             pUI->pName = new String(aResId);
 448     }
 449     else
 450         pUI->pName = new String(*pStr);
 451
 452     return pUI;
 453 }
 454
 455 const ResId& SfxInterface::GetObjectBarResId( USHORT nNo ) const
 456 {
 457     BOOL bGenoType = (pGenoType != 0 && !pGenoType->HasName());
 458     if ( bGenoType )
 459     {
 460         // Gibt es Toolbars in der Superklasse ?
 461         USHORT nBaseCount = pGenoType->GetObjectBarCount();
 462         if ( nNo < nBaseCount )
 463             // Die der Superklasse kommen zuerst
 464             return pGenoType->GetObjectBarResId( nNo );
 465         else
 466             nNo = nNo - nBaseCount;
 467     }
 468
 469 #ifdef DBG_UTIL
 470     USHORT nObjBarCount = pImpData->pObjectBars->Count();
 471     DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" );
 472 #endif
 473     return (*pImpData->pObjectBars)[nNo]->aResId;
 474 }
 475
 476 //--------------------------------------------------------------------
 477
 478
 479 USHORT SfxInterface::GetObjectBarPos( USHORT nNo ) const
 480 {
 481     BOOL bGenoType = (pGenoType != 0 && !pGenoType->HasName());
 482     if ( bGenoType )
 483     {
 484         // Gibt es Toolbars in der Superklasse ?
 485         USHORT nBaseCount = pGenoType->GetObjectBarCount();
 486         if ( nNo < nBaseCount )
 487             // Die der Superklasse kommen zuerst
 488             return pGenoType->GetObjectBarPos( nNo );
 489         else
 490             nNo = nNo - nBaseCount;
 491     }
 492
 493 #ifdef DBG_UTIL
 494     USHORT nObjBarCount = pImpData->pObjectBars->Count();
 495     DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" );
 496 #endif
 497     return (*pImpData->pObjectBars)[nNo]->nPos;
 498 }
 499
 500 //--------------------------------------------------------------------
 501
 502
 503 USHORT SfxInterface::GetObjectBarCount() const
 504 {
 505     if (pGenoType && ! pGenoType->HasName())
 506         return pImpData->pObjectBars->Count() + pGenoType->GetObjectBarCount();
 507     else
 508         return pImpData->pObjectBars->Count();
 509 }
 510
 511 //--------------------------------------------------------------------
 512 void SfxInterface::RegisterChildWindow(USHORT nId, BOOL bContext, const String* pChildWinName)
 513 {
 514     RegisterChildWindow( nId, bContext, 0UL, pChildWinName );
 515 }
 516
 517 void SfxInterface::RegisterChildWindow(USHORT nId, BOOL bContext, sal_uInt32 nFeature, const String*)
 518 {
 519     SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(0, ResId(nId, *SfxApplication::GetOrCreate()->GetOffResManager_Impl()), TRUE, nFeature);
 520     pUI->bContext = bContext;
 521     pImpData->pChildWindows->Append(pUI);
 522 }
 523
 524 void SfxInterface::RegisterStatusBar(const ResId& rResId)
 525 {
 526     pImpData->aStatBarRes = rResId;
 527 }
 528
 529
 530 sal_uInt32 SfxInterface::GetChildWindowId (USHORT nNo) const
 531 {
 532     if ( pGenoType )
 533     {
 534         // Gibt es ChildWindows in der Superklasse ?
 535         USHORT nBaseCount = pGenoType->GetChildWindowCount();
 536         if ( nNo < nBaseCount )
 537             // Die der Superklasse kommen zuerst
 538             return pGenoType->GetChildWindowId( nNo );
 539         else
 540             nNo = nNo - nBaseCount;
 541     }
 542
 543 #ifdef DBG_UTIL
 544     USHORT nCWCount = pImpData->pChildWindows->Count();
 545     DBG_ASSERT( nNo<nCWCount,"ChildWindow ist unbekannt!" );
 546 #endif
 547     sal_uInt32 nRet = (*pImpData->pChildWindows)[nNo]->aResId.GetId();
 548     if ( (*pImpData->pChildWindows)[nNo]->bContext )
 549         nRet += sal_uInt32( nClassId ) << 16;
 550     return nRet;
 551 }
 552
 553 sal_uInt32 SfxInterface::GetChildWindowFeature (USHORT nNo) const
 554 {
 555     if ( pGenoType )
 556     {
 557         // Gibt es ChildWindows in der Superklasse ?
 558         USHORT nBaseCount = pGenoType->GetChildWindowCount();
 559         if ( nNo < nBaseCount )
 560             // Die der Superklasse kommen zuerst
 561             return pGenoType->GetChildWindowFeature( nNo );
 562         else
 563             nNo = nNo - nBaseCount;
 564     }
 565
 566 #ifdef DBG_UTIL
 567     USHORT nCWCount = pImpData->pChildWindows->Count();
 568     DBG_ASSERT( nNo<nCWCount,"ChildWindow ist unbekannt!" );
 569 #endif
 570     return (*pImpData->pChildWindows)[nNo]->nFeature;
 571 }
 572
 573 //--------------------------------------------------------------------
 574
 575
 576 USHORT SfxInterface::GetChildWindowCount() const
 577 {
 578     if (pGenoType)
 579         return pImpData->pChildWindows->Count() + pGenoType->GetChildWindowCount();
 580     else
 581         return pImpData->pChildWindows->Count();
 582 }
 583
 584
 585 const ResId& SfxInterface::GetPopupMenuResId() const
 586 {
 587     return pImpData->aPopupRes;
 588 }
 589
 590
 591 const ResId& SfxInterface::GetStatusBarResId() const
 592 {
 593     if (pImpData->aStatBarRes.GetId() == 0 && pGenoType)
 594         return pGenoType->GetStatusBarResId();
 595     else
 596         return pImpData->aStatBarRes;
 597 }
 598
 599
 600
 601 const String* SfxInterface::GetObjectBarName ( USHORT nNo ) const
 602 {
 603     BOOL bGenoType = (pGenoType != 0 && !pGenoType->HasName());
 604     if ( bGenoType )
 605     {
 606         // Gibt es Toolbars in der Superklasse ?
 607         USHORT nBaseCount = pGenoType->GetObjectBarCount();
 608         if ( nNo < nBaseCount )
 609             // Die der Superklasse kommen zuerst
 610             return pGenoType->GetObjectBarName( nNo );
 611         else
 612             nNo = nNo - nBaseCount;
 613     }
 614
 615 #ifdef DBG_UTIL
 616     USHORT nObjBarCount = pImpData->pObjectBars->Count();
 617     DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" );
 618 #endif
 619     return (*pImpData->pObjectBars)[nNo]->pName;
 620 }
 621
 622 sal_uInt32 SfxInterface::GetObjectBarFeature ( USHORT nNo ) const
 623 {
 624     BOOL bGenoType = (pGenoType != 0 && !pGenoType->HasName());
 625     if ( bGenoType )
 626     {
 627         // Gibt es Toolbars in der Superklasse ?
 628         USHORT nBaseCount = pGenoType->GetObjectBarCount();
 629         if ( nNo < nBaseCount )
 630             // Die der Superklasse kommen zuerst
 631             return pGenoType->GetObjectBarFeature( nNo );
 632         else
 633             nNo = nNo - nBaseCount;
 634     }
 635
 636 #ifdef DBG_UTIL
 637     USHORT nObjBarCount = pImpData->pObjectBars->Count();
 638     DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" );
 639 #endif
 640     return (*pImpData->pObjectBars)[nNo]->nFeature;
 641 }
 642
 643 BOOL SfxInterface::IsObjectBarVisible(USHORT nNo) const
 644 {
 645     BOOL bGenoType = (pGenoType != 0 && !pGenoType->HasName());
 646     if ( bGenoType )
 647     {
 648         // Gibt es Toolbars in der Superklasse ?
 649         USHORT nBaseCount = pGenoType->GetObjectBarCount();
 650         if ( nNo < nBaseCount )
 651             // Die der Superklasse kommen zuerst
 652             return pGenoType->IsObjectBarVisible( nNo );
 653         else
 654             nNo = nNo - nBaseCount;
 655     }
 656
 657 #ifdef DBG_UTIL
 658     USHORT nObjBarCount = pImpData->pObjectBars->Count();
 659     DBG_ASSERT( nNo<nObjBarCount,"Objectbar ist unbekannt!" );
 660 #endif
 661     return (*pImpData->pObjectBars)[nNo]->bVisible;
 662 }
 663
 664 const SfxInterface* SfxInterface::GetRealInterfaceForSlot( const SfxSlot *pRealSlot ) const
 665 {
 666     DBG_ASSERT( pImpData->bRegistered, "Interface not registered!" );
 667     const SfxInterface* pInterface = this;
 668
 669     // Der Slot k"onnte auch aus dem Interface einer Shell-Basisklasse stammen
 670     do
 671     {
 672         const SfxSlot *pLastSlot  = (*pInterface)[pInterface->Count()-1];
 673         const SfxSlot *pFirstSlot = (*pInterface)[0];
 674
 675         // Ist pInterface der Owner von pRealSlot ?
 676         if ( pFirstSlot <= pRealSlot && pRealSlot <= pLastSlot )
 677             break;
 678
 679         // Sonst Interface der Superklasse probieren
 680         pInterface = pInterface->pGenoType;
 681     }
 682     while ( pInterface );
 683
 684     return pInterface;
 685 }
 686
 687
 688