sfx2/source/control/objface.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22
  23 #include <sal/log.hxx>
  24
  25 #include <sfx2/module.hxx>
  26 #include <sfx2/objface.hxx>
  27 #include <sfx2/msg.hxx>
  28 #include <sfx2/app.hxx>
  29 #include <sfx2/msgpool.hxx>
  30
  31 extern "C" {
  32
  33 static int
  34 SfxCompareSlots_qsort( const void* pSmaller, const void* pBigger )
  35 {
  36     return static_cast<int>(static_cast<SfxSlot const *>(pSmaller)->GetSlotId()) -
  37            static_cast<int>(static_cast<SfxSlot const *>(pBigger)->GetSlotId());
  38 }
  39
  40 static int
  41 SfxCompareSlots_bsearch( const void* pSmaller, const void* pBigger )
  42 {
  43     return static_cast<int>(*static_cast<sal_uInt16 const *>(pSmaller)) -
  44            static_cast<int>(static_cast<SfxSlot const *>(pBigger)->GetSlotId());
  45 }
  46
  47 }
  48
  49 namespace {
  50
  51 struct SfxObjectUI_Impl
  52 {
  53     sal_uInt16         nPos;
  54     SfxVisibilityFlags nFlags;
  55     sal_uInt32         nObjId;
  56     bool               bContext;
  57     SfxShellFeature    nFeature;
  58
  59     SfxObjectUI_Impl(sal_uInt16 n, SfxVisibilityFlags f, sal_uInt32 nId, SfxShellFeature nFeat) :
  60         nPos(n),
  61         nFlags(f),
  62         nObjId(nId),
  63         bContext(false),
  64         nFeature(nFeat)
  65     {
  66     }
  67 };
  68
  69 }
  70
  71 struct SfxInterface_Impl
  72 {
  73     std::vector<std::unique_ptr<SfxObjectUI_Impl>>
  74                             aObjectBars;    // registered ObjectBars
  75     std::vector<std::unique_ptr<SfxObjectUI_Impl>>
  76                             aChildWindows;  // registered ChildWindows
  77     OUString                aPopupName;     // registered PopupMenu
  78     StatusBarId             eStatBarResId;  // registered StatusBar
  79
  80     SfxInterface_Impl()
  81         : eStatBarResId(StatusBarId::None)
  82     {
  83     }
  84 };
  85
  86 static SfxObjectUI_Impl* CreateObjectBarUI_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature);
  87
  88 // constructor, registers a new unit
  89 SfxInterface::SfxInterface( const char *pClassName,
  90                             bool bUsableSuperClass,
  91                             SfxInterfaceId nId,
  92                             const SfxInterface* pParent,
  93                             SfxSlot &rSlotMap, sal_uInt16 nSlotCount ):
  94     pName(pClassName),
  95     pGenoType(pParent),
  96     nClassId(nId),
  97     bSuperClass(bUsableSuperClass),
  98     pImplData(new SfxInterface_Impl)
  99 {
 100     SetSlotMap( rSlotMap, nSlotCount );
 101 }
 102
 103 void SfxInterface::Register( const SfxModule* pMod )
 104 {
 105     if ( pMod )
 106         pMod->GetSlotPool()->RegisterInterface(*this);
 107     else
 108         SfxGetpApp()->GetAppSlotPool_Impl().RegisterInterface(*this);
 109 }
 110
 111 void SfxInterface::SetSlotMap( SfxSlot& rSlotMap, sal_uInt16 nSlotCount )
 112 {
 113     pSlots = &rSlotMap;
 114     nCount = nSlotCount;
 115     SfxSlot* pIter = pSlots;
 116     if ( 1 == nCount && !pIter->pNextSlot )
 117         pIter->pNextSlot = pIter;
 118
 119     if ( !pIter->pNextSlot )
 120     {
 121         // sort the SfxSlots by id
 122         qsort( pSlots, nCount, sizeof(SfxSlot), SfxCompareSlots_qsort );
 123
 124         // link masters and slaves
 125         sal_uInt16 nIter = 1;
 126         for ( pIter = pSlots; nIter <= nCount; ++pIter, ++nIter )
 127         {
 128
 129             assert( nIter == nCount ||
 130                     pIter->GetSlotId() != (pIter+1)->GetSlotId() );
 131
 132             if ( nullptr == pIter->GetNextSlot() )
 133             {
 134                 // Slots referring in circle to the next with the same
 135                 // Status method.
 136                 SfxSlot *pLastSlot = pIter;
 137                 for ( sal_uInt16 n = nIter; n < Count(); ++n )
 138                 {
 139                     SfxSlot *pCurSlot = pSlots+n;
 140                     if ( pCurSlot->GetStateFnc() == pIter->GetStateFnc() )
 141                     {
 142                         pLastSlot->pNextSlot = pCurSlot;
 143                         pLastSlot = pCurSlot;
 144                     }
 145                 }
 146                 pLastSlot->pNextSlot = pIter;
 147             }
 148         }
 149     }
 150 #ifdef DBG_UTIL
 151     else
 152     {
 153         sal_uInt16 nIter = 1;
 154         for ( SfxSlot *pNext = pIter+1; nIter < nCount; ++pNext, ++nIter )
 155         {
 156
 157             if ( pNext->GetSlotId() <= pIter->GetSlotId() )
 158                 SAL_WARN( "sfx.control", "Wrong order" );
 159
 160             const SfxSlot *pCurSlot = pIter;
 161             do
 162             {
 163                 pCurSlot = pCurSlot->pNextSlot;
 164                 if ( pCurSlot->GetStateFnc() != pIter->GetStateFnc() )
 165                 {
 166                     SAL_WARN("sfx.control", "Linked Slots with different State Methods : "
 167                                 << pCurSlot->GetSlotId()
 168                                 << " , " << pIter->GetSlotId() );
 169                 }
 170             }
 171             while ( pCurSlot != pIter );
 172
 173             pIter = pNext;
 174         }
 175     }
 176 #endif
 177 }
 178
 179
 180 SfxInterface::~SfxInterface()
 181 {
 182 }
 183
 184
 185 // searches for the specified func
 186
 187 const SfxSlot* SfxInterface::GetSlot( sal_uInt16 nFuncId ) const
 188 {
 189
 190     assert( pSlots );
 191     assert( nCount );
 192
 193     // find the id using binary search
 194     void* p = bsearch( &nFuncId, pSlots, nCount, sizeof(SfxSlot),
 195                        SfxCompareSlots_bsearch );
 196     if ( !p && pGenoType )
 197         return pGenoType->GetSlot( nFuncId );
 198
 199     return static_cast<const SfxSlot*>(p);
 200 }
 201
 202 const SfxSlot* SfxInterface::GetSlot( const OUString& rCommand ) const
 203 {
 204     static const char UNO_COMMAND[] = ".uno:";
 205
 206     OUString aCommand( rCommand );
 207     if ( aCommand.startsWith( UNO_COMMAND ) )
 208          aCommand = aCommand.copy( sizeof( UNO_COMMAND )-1 );
 209
 210     for ( sal_uInt16 n=0; n<nCount; n++ )
 211     {
 212         if ( (pSlots+n)->pUnoName &&
 213              aCommand.compareToIgnoreAsciiCaseAscii( (pSlots+n)->GetUnoName() ) == 0 )
 214             return pSlots+n;
 215     }
 216
 217     return pGenoType ? pGenoType->GetSlot( aCommand ) : nullptr;
 218 }
 219
 220
 221 const SfxSlot* SfxInterface::GetRealSlot( const SfxSlot *pSlot ) const
 222 {
 223
 224     assert( pSlots );
 225     assert( nCount );
 226
 227     if ( !ContainsSlot_Impl(pSlot) )
 228     {
 229         if(pGenoType)
 230             return pGenoType->GetRealSlot(pSlot);
 231         SAL_WARN( "sfx.control", "unknown Slot" );
 232         return nullptr;
 233     }
 234
 235     return nullptr;
 236 }
 237
 238
 239 void SfxInterface::RegisterPopupMenu( const OUString& rResourceName )
 240 {
 241     pImplData->aPopupName = rResourceName;
 242 }
 243
 244 void SfxInterface::RegisterObjectBar(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId)
 245 {
 246     RegisterObjectBar(nPos, nFlags, eId, SfxShellFeature::NONE);
 247 }
 248
 249 void SfxInterface::RegisterObjectBar(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature)
 250 {
 251     SfxObjectUI_Impl* pUI = CreateObjectBarUI_Impl(nPos, nFlags, eId, nFeature);
 252     if ( pUI )
 253         pImplData->aObjectBars.emplace_back(pUI);
 254 }
 255
 256 SfxObjectUI_Impl* CreateObjectBarUI_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature)
 257 {
 258     if (nFlags == SfxVisibilityFlags::Invisible)
 259         nFlags |= SfxVisibilityFlags::Standard;
 260
 261     return new SfxObjectUI_Impl(nPos, nFlags, static_cast<sal_uInt32>(eId), nFeature);
 262 }
 263
 264 ToolbarId SfxInterface::GetObjectBarId(sal_uInt16 nNo) const
 265 {
 266     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 267     if ( bGenoType )
 268     {
 269         // Are there toolbars in the super class?
 270         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 271         if ( nNo < nBaseCount )
 272             // The Super class comes first
 273             return pGenoType->GetObjectBarId(nNo);
 274         else
 275             nNo = nNo - nBaseCount;
 276     }
 277
 278     assert( nNo<pImplData->aObjectBars.size() );
 279
 280     return static_cast<ToolbarId>(pImplData->aObjectBars[nNo]->nObjId);
 281 }
 282
 283 sal_uInt16 SfxInterface::GetObjectBarPos( sal_uInt16 nNo ) const
 284 {
 285     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 286     if ( bGenoType )
 287     {
 288         // Are there toolbars in the super class?
 289         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 290         if ( nNo < nBaseCount )
 291             // The Super class comes first
 292             return pGenoType->GetObjectBarPos( nNo );
 293         else
 294             nNo = nNo - nBaseCount;
 295     }
 296
 297     assert( nNo<pImplData->aObjectBars.size() );
 298
 299     return pImplData->aObjectBars[nNo]->nPos;
 300 }
 301
 302 SfxVisibilityFlags SfxInterface::GetObjectBarFlags( sal_uInt16 nNo ) const
 303 {
 304     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 305     if ( bGenoType )
 306     {
 307         // Are there toolbars in the super class?
 308         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 309         if ( nNo < nBaseCount )
 310             // The Super class comes first
 311             return pGenoType->GetObjectBarFlags( nNo );
 312         else
 313             nNo = nNo - nBaseCount;
 314     }
 315
 316     assert( nNo<pImplData->aObjectBars.size() );
 317
 318     return pImplData->aObjectBars[nNo]->nFlags;
 319 }
 320
 321 sal_uInt16 SfxInterface::GetObjectBarCount() const
 322 {
 323     if (pGenoType && pGenoType->UseAsSuperClass())
 324         return pImplData->aObjectBars.size() + pGenoType->GetObjectBarCount();
 325     else
 326         return pImplData->aObjectBars.size();
 327 }
 328
 329 void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext)
 330 {
 331     RegisterChildWindow(nId, bContext, SfxShellFeature::NONE);
 332 }
 333
 334 void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext, SfxShellFeature nFeature)
 335 {
 336     SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(0, SfxVisibilityFlags::Invisible, nId, nFeature);
 337     pUI->bContext = bContext;
 338     pImplData->aChildWindows.emplace_back(pUI);
 339 }
 340
 341 void SfxInterface::RegisterStatusBar(StatusBarId eId)
 342 {
 343     pImplData->eStatBarResId = eId;
 344 }
 345
 346 sal_uInt32 SfxInterface::GetChildWindowId (sal_uInt16 nNo) const
 347 {
 348     if ( pGenoType )
 349     {
 350         // Are there ChildWindows in the superclass?
 351         sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
 352         if ( nNo < nBaseCount )
 353             // The Super class comes first
 354             return pGenoType->GetChildWindowId( nNo );
 355         else
 356             nNo = nNo - nBaseCount;
 357     }
 358
 359     assert( nNo<pImplData->aChildWindows.size() );
 360
 361     sal_uInt32 nRet = pImplData->aChildWindows[nNo]->nObjId;
 362     if ( pImplData->aChildWindows[nNo]->bContext )
 363         nRet += sal_uInt16( nClassId ) << 16;
 364     return nRet;
 365 }
 366
 367 SfxShellFeature SfxInterface::GetChildWindowFeature (sal_uInt16 nNo) const
 368 {
 369     if ( pGenoType )
 370     {
 371         // Are there ChildWindows in the superclass?
 372         sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
 373         if ( nNo < nBaseCount )
 374             // The Super class comes first
 375             return pGenoType->GetChildWindowFeature( nNo );
 376         else
 377             nNo = nNo - nBaseCount;
 378     }
 379
 380     assert( nNo<pImplData->aChildWindows.size() );
 381
 382     return pImplData->aChildWindows[nNo]->nFeature;
 383 }
 384
 385
 386 sal_uInt16 SfxInterface::GetChildWindowCount() const
 387 {
 388     if (pGenoType)
 389         return pImplData->aChildWindows.size() + pGenoType->GetChildWindowCount();
 390     else
 391         return pImplData->aChildWindows.size();
 392 }
 393
 394 const OUString& SfxInterface::GetPopupMenuName() const
 395 {
 396     return pImplData->aPopupName;
 397 }
 398
 399 StatusBarId SfxInterface::GetStatusBarId() const
 400 {
 401     if (pImplData->eStatBarResId == StatusBarId::None && pGenoType)
 402         return pGenoType->GetStatusBarId();
 403     else
 404         return pImplData->eStatBarResId;
 405 }
 406
 407 SfxShellFeature SfxInterface::GetObjectBarFeature ( sal_uInt16 nNo ) const
 408 {
 409     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 410     if ( bGenoType )
 411     {
 412         // Are there toolbars in the super class?
 413         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 414         if ( nNo < nBaseCount )
 415             // The Super class comes first
 416             return pGenoType->GetObjectBarFeature( nNo );
 417         else
 418             nNo = nNo - nBaseCount;
 419     }
 420
 421     assert( nNo<pImplData->aObjectBars.size() );
 422
 423     return pImplData->aObjectBars[nNo]->nFeature;
 424 }
 425
 426 bool SfxInterface::IsObjectBarVisible(sal_uInt16 nNo) const
 427 {
 428     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 429     if ( bGenoType )
 430     {
 431         // Are there toolbars in the super class?
 432         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 433         if ( nNo < nBaseCount )
 434             // The Super class comes first
 435             return pGenoType->IsObjectBarVisible( nNo );
 436         else
 437             nNo = nNo - nBaseCount;
 438     }
 439
 440     assert( nNo<pImplData->aObjectBars.size() );
 441
 442     return true;
 443 }
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */