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<SfxObjectUI_Impl>
  74                             aObjectBars;    // registered ObjectBars
  75     std::vector<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     pImplData->aObjectBars.emplace_back( CreateObjectBarUI_Impl(nPos, nFlags, eId, nFeature) );
 252 }
 253
 254 SfxObjectUI_Impl CreateObjectBarUI_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature)
 255 {
 256     if (nFlags == SfxVisibilityFlags::Invisible)
 257         nFlags |= SfxVisibilityFlags::Standard;
 258
 259     return SfxObjectUI_Impl(nPos, nFlags, static_cast<sal_uInt32>(eId), nFeature);
 260 }
 261
 262 ToolbarId SfxInterface::GetObjectBarId(sal_uInt16 nNo) const
 263 {
 264     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 265     if ( bGenoType )
 266     {
 267         // Are there toolbars in the super class?
 268         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 269         if ( nNo < nBaseCount )
 270             // The Super class comes first
 271             return pGenoType->GetObjectBarId(nNo);
 272         else
 273             nNo = nNo - nBaseCount;
 274     }
 275
 276     assert( nNo<pImplData->aObjectBars.size() );
 277
 278     return static_cast<ToolbarId>(pImplData->aObjectBars[nNo].nObjId);
 279 }
 280
 281 sal_uInt16 SfxInterface::GetObjectBarPos( sal_uInt16 nNo ) const
 282 {
 283     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 284     if ( bGenoType )
 285     {
 286         // Are there toolbars in the super class?
 287         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 288         if ( nNo < nBaseCount )
 289             // The Super class comes first
 290             return pGenoType->GetObjectBarPos( nNo );
 291         else
 292             nNo = nNo - nBaseCount;
 293     }
 294
 295     assert( nNo<pImplData->aObjectBars.size() );
 296
 297     return pImplData->aObjectBars[nNo].nPos;
 298 }
 299
 300 SfxVisibilityFlags SfxInterface::GetObjectBarFlags( sal_uInt16 nNo ) const
 301 {
 302     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 303     if ( bGenoType )
 304     {
 305         // Are there toolbars in the super class?
 306         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 307         if ( nNo < nBaseCount )
 308             // The Super class comes first
 309             return pGenoType->GetObjectBarFlags( nNo );
 310         else
 311             nNo = nNo - nBaseCount;
 312     }
 313
 314     assert( nNo<pImplData->aObjectBars.size() );
 315
 316     return pImplData->aObjectBars[nNo].nFlags;
 317 }
 318
 319 sal_uInt16 SfxInterface::GetObjectBarCount() const
 320 {
 321     if (pGenoType && pGenoType->UseAsSuperClass())
 322         return pImplData->aObjectBars.size() + pGenoType->GetObjectBarCount();
 323     else
 324         return pImplData->aObjectBars.size();
 325 }
 326
 327 void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext)
 328 {
 329     RegisterChildWindow(nId, bContext, SfxShellFeature::NONE);
 330 }
 331
 332 void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext, SfxShellFeature nFeature)
 333 {
 334     SfxObjectUI_Impl aUI(0, SfxVisibilityFlags::Invisible, nId, nFeature);
 335     aUI.bContext = bContext;
 336     pImplData->aChildWindows.emplace_back(aUI);
 337 }
 338
 339 void SfxInterface::RegisterStatusBar(StatusBarId eId)
 340 {
 341     pImplData->eStatBarResId = eId;
 342 }
 343
 344 sal_uInt32 SfxInterface::GetChildWindowId (sal_uInt16 nNo) const
 345 {
 346     if ( pGenoType )
 347     {
 348         // Are there ChildWindows in the superclass?
 349         sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
 350         if ( nNo < nBaseCount )
 351             // The Super class comes first
 352             return pGenoType->GetChildWindowId( nNo );
 353         else
 354             nNo = nNo - nBaseCount;
 355     }
 356
 357     assert( nNo<pImplData->aChildWindows.size() );
 358
 359     sal_uInt32 nRet = pImplData->aChildWindows[nNo].nObjId;
 360     if ( pImplData->aChildWindows[nNo].bContext )
 361         nRet += sal_uInt16( nClassId ) << 16;
 362     return nRet;
 363 }
 364
 365 SfxShellFeature SfxInterface::GetChildWindowFeature (sal_uInt16 nNo) const
 366 {
 367     if ( pGenoType )
 368     {
 369         // Are there ChildWindows in the superclass?
 370         sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
 371         if ( nNo < nBaseCount )
 372             // The Super class comes first
 373             return pGenoType->GetChildWindowFeature( nNo );
 374         else
 375             nNo = nNo - nBaseCount;
 376     }
 377
 378     assert( nNo<pImplData->aChildWindows.size() );
 379
 380     return pImplData->aChildWindows[nNo].nFeature;
 381 }
 382
 383
 384 sal_uInt16 SfxInterface::GetChildWindowCount() const
 385 {
 386     if (pGenoType)
 387         return pImplData->aChildWindows.size() + pGenoType->GetChildWindowCount();
 388     else
 389         return pImplData->aChildWindows.size();
 390 }
 391
 392 const OUString& SfxInterface::GetPopupMenuName() const
 393 {
 394     return pImplData->aPopupName;
 395 }
 396
 397 StatusBarId SfxInterface::GetStatusBarId() const
 398 {
 399     if (pImplData->eStatBarResId == StatusBarId::None && pGenoType)
 400         return pGenoType->GetStatusBarId();
 401     else
 402         return pImplData->eStatBarResId;
 403 }
 404
 405 SfxShellFeature SfxInterface::GetObjectBarFeature ( sal_uInt16 nNo ) const
 406 {
 407     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 408     if ( bGenoType )
 409     {
 410         // Are there toolbars in the super class?
 411         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 412         if ( nNo < nBaseCount )
 413             // The Super class comes first
 414             return pGenoType->GetObjectBarFeature( nNo );
 415         else
 416             nNo = nNo - nBaseCount;
 417     }
 418
 419     assert( nNo<pImplData->aObjectBars.size() );
 420
 421     return pImplData->aObjectBars[nNo].nFeature;
 422 }
 423
 424 bool SfxInterface::IsObjectBarVisible(sal_uInt16 nNo) const
 425 {
 426     bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
 427     if ( bGenoType )
 428     {
 429         // Are there toolbars in the super class?
 430         sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
 431         if ( nNo < nBaseCount )
 432             // The Super class comes first
 433             return pGenoType->IsObjectBarVisible( nNo );
 434         else
 435             nNo = nNo - nBaseCount;
 436     }
 437
 438     assert( nNo<pImplData->aObjectBars.size() );
 439
 440     return true;
 441 }
 442
 443 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */