sfx2/source/control/msgpool.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 <tools/stream.hxx>
  21 #include <rsc/rscsfx.hxx>
  22
  23 // due to pSlotPool
  24 #include "appdata.hxx"
  25 #include <sfx2/msgpool.hxx>
  26 #include <sfx2/msg.hxx>
  27 #include <sfx2/app.hxx>
  28 #include <sfx2/objface.hxx>
  29 #include "sfxtypes.hxx"
  30 #include <sfx2/sfxresid.hxx>
  31 #include "arrdecl.hxx"
  32 #include <sfx2/module.hxx>
  33
  34 #include <sfx2/sfx.hrc>
  35
  36 SfxSlotPool::SfxSlotPool(SfxSlotPool *pParent)
  37  : _pGroups(0)
  38  , _pParentPool( pParent )
  39  , _pInterfaces(0)
  40  , _nCurGroup(0)
  41  , _nCurInterface(0)
  42  , _nCurMsg(0)
  43 {
  44 }
  45
  46 SfxSlotPool::~SfxSlotPool()
  47 {
  48     _pParentPool = 0;
  49     for ( SfxInterface *pIF = FirstInterface(); pIF; pIF = FirstInterface() )
  50         delete pIF;
  51     delete _pInterfaces;
  52     delete _pGroups;
  53 }
  54
  55
  56 // registers the availability of the Interface of functions
  57
  58 void SfxSlotPool::RegisterInterface( SfxInterface& rInterface )
  59 {
  60     // add to the list of SfxObjectInterface instances
  61     if ( _pInterfaces == NULL )
  62         _pInterfaces = new SfxInterfaceArr_Impl;
  63     _pInterfaces->push_back(&rInterface);
  64
  65     // Stop at a (single) Null-slot (for syntactic reasons the interfaces
  66     // always contain at least one slot)
  67     if ( rInterface.Count() != 0 && !rInterface[0]->nSlotId )
  68         return;
  69
  70     // possibly add Interface-id and group-ids of funcs to the list of groups
  71     if ( !_pGroups )
  72     {
  73         _pGroups = new SfxSlotGroupArr_Impl;
  74
  75         if ( _pParentPool )
  76         {
  77             // The Groups in parent Slotpool are also known here
  78             _pGroups->append( *_pParentPool->_pGroups );
  79         }
  80     }
  81
  82     for ( size_t nFunc = 0; nFunc < rInterface.Count(); ++nFunc )
  83     {
  84         SfxSlot *pDef = rInterface[nFunc];
  85         if ( pDef->GetGroupId() && /* pDef->GetGroupId() != GID_INTERN && */
  86              _pGroups->find(pDef->GetGroupId()) == SfxSlotGroupArr_Impl::npos )
  87         {
  88             if (pDef->GetGroupId() == GID_INTERN)
  89                 _pGroups->insert(_pGroups->begin(), pDef->GetGroupId());
  90             else
  91                 _pGroups->push_back(pDef->GetGroupId());
  92         }
  93     }
  94 }
  95
  96
  97
  98 TypeId SfxSlotPool::GetSlotType( sal_uInt16 nId ) const
  99 {
 100     const SfxSlot* pSlot = (const_cast <SfxSlotPool*> (this))->GetSlot( nId );
 101     return pSlot ? pSlot->GetType()->Type() : 0;
 102 }
 103
 104
 105 // unregisters the availability of the Interface of functions
 106
 107 void SfxSlotPool::ReleaseInterface( SfxInterface& rInterface )
 108 {
 109     SAL_WARN_IF(!_pInterfaces, "sfx.control", "releasing SfxInterface, but there are none");
 110     if (!_pInterfaces)
 111         return ;
 112
 113     // remove from the list of SfxInterface instances
 114     SfxInterfaceArr_Impl::iterator i = std::find(_pInterfaces->begin(), _pInterfaces->end(), &rInterface);
 115     if(i != _pInterfaces->end())
 116         _pInterfaces->erase(i);
 117 }
 118
 119 // get the first SfxMessage for a special Id (e.g. for getting check-mode)
 120
 121 const SfxSlot* SfxSlotPool::GetSlot( sal_uInt16 nId )
 122 {
 123     SAL_WARN_IF(!_pInterfaces, "sfx.control", "no Interfaces registered");
 124     if (!_pInterfaces)
 125         return 0;
 126
 127     // First, search their own interfaces
 128     for ( sal_uInt16 nInterf = 0; nInterf < _pInterfaces->size(); ++nInterf )
 129     {
 130         const SfxSlot *pDef = ((*_pInterfaces)[nInterf])->GetSlot(nId);
 131         if ( pDef )
 132             return pDef;
 133     }
 134
 135     // Then try any of the possible existing parent
 136     return _pParentPool ? _pParentPool->GetSlot( nId ) : 0;
 137 }
 138
 139
 140
 141 // skips to the next group
 142
 143 OUString SfxSlotPool::SeekGroup( sal_uInt16 nNo )
 144 {
 145     SAL_WARN_IF(!_pInterfaces, "sfx.control", "no Interfaces registered");
 146
 147     // if the group exists, use it
 148     if ( _pGroups && nNo < _pGroups->size() )
 149     {
 150         _nCurGroup = nNo;
 151         if ( _pParentPool )
 152         {
 153             // In most cases, the order of the IDs agree
 154             sal_uInt16 nParentCount = _pParentPool->_pGroups->size();
 155             if ( nNo < nParentCount && (*_pGroups)[nNo] == (*_pParentPool->_pGroups)[nNo] )
 156                 _pParentPool->_nCurGroup = nNo;
 157             else
 158             {
 159                 // Otherwise search. If the group is not found in the parent
 160                 // pool, _nCurGroup is set outside the valid range
 161                 sal_uInt16 i;
 162                 for ( i=1; i<nParentCount; i++ )
 163                     if ( (*_pGroups)[nNo] == (*_pParentPool->_pGroups)[i] )
 164                         break;
 165                 _pParentPool->_nCurGroup = i;
 166             }
 167         }
 168
 169         SfxResId aResId( (*_pGroups)[_nCurGroup] );
 170         aResId.SetRT(RSC_STRING);
 171         if ( !SfxResId::GetResMgr()->IsAvailable(aResId) )
 172         {
 173             OSL_FAIL( "GroupId-Name not defined in SFX!" );
 174             return OUString();
 175         }
 176
 177         return aResId.toString();
 178     }
 179
 180     return OUString();
 181 }
 182
 183
 184
 185
 186 sal_uInt16 SfxSlotPool::GetGroupCount()
 187 {
 188     return _pGroups->size();
 189 }
 190
 191
 192
 193
 194 // internal search loop
 195
 196 const SfxSlot* SfxSlotPool::SeekSlot( sal_uInt16 nStartInterface )
 197 {
 198     SAL_WARN_IF(!_pInterfaces, "sfx.control", "no Interfaces registered");
 199     if (!_pInterfaces)
 200         return 0;
 201
 202     // The numbering starts at the interfaces of the parent pool
 203     sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_pInterfaces->size() : 0;
 204
 205     // have reached the end of the Parent-Pools?
 206     if ( nStartInterface < nFirstInterface &&
 207          _pParentPool->_nCurGroup >= _pParentPool->_pGroups->size() )
 208         nStartInterface = nFirstInterface;
 209
 210     // Is the Interface still in the Parent-Pool?
 211     if ( nStartInterface < nFirstInterface )
 212     {
 213         SAL_WARN_IF(!_pParentPool, "sfx.control", "No parent pool!");
 214         _nCurInterface = nStartInterface;
 215         return _pParentPool->SeekSlot( nStartInterface );
 216     }
 217
 218     // find the first func-def with the current group id
 219     sal_uInt16 nCount = _pInterfaces->size() + nFirstInterface;
 220     for ( _nCurInterface = nStartInterface;
 221             _nCurInterface < nCount;
 222           ++_nCurInterface )
 223     {
 224         SfxInterface* pInterface = (*_pInterfaces)[_nCurInterface-nFirstInterface];
 225         for ( _nCurMsg = 0;
 226               _nCurMsg < pInterface->Count();
 227               ++_nCurMsg )
 228         {
 229             const SfxSlot* pMsg = (*pInterface)[_nCurMsg];
 230             if ( pMsg->GetGroupId() == _pGroups->at(_nCurGroup) )
 231                 return pMsg;
 232         }
 233     }
 234
 235     return 0;
 236 }
 237
 238
 239 // skips to the next func in the current group
 240
 241 const SfxSlot* SfxSlotPool::NextSlot()
 242 {
 243     SAL_WARN_IF(!_pInterfaces, "sfx.control", "no Interfaces registered");
 244     if (!_pInterfaces)
 245         return 0;
 246
 247     // The numbering starts at the interfaces of the parent pool
 248     sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_pInterfaces->size() : 0;
 249
 250     if ( _nCurInterface < nFirstInterface && _nCurGroup >= _pParentPool->_pGroups->size() )
 251         _nCurInterface = nFirstInterface;
 252
 253     if ( _nCurInterface < nFirstInterface )
 254     {
 255         SAL_WARN_IF(!_pParentPool, "sfx.control", "No parent pool!");
 256         const SfxSlot *pSlot = _pParentPool->NextSlot();
 257         _nCurInterface = _pParentPool->_nCurInterface;
 258         if ( pSlot )
 259             return pSlot;
 260         if ( _nCurInterface == nFirstInterface )
 261             // parent pool is ready
 262             return SeekSlot( nFirstInterface );
 263     }
 264
 265     sal_uInt16 nInterface = _nCurInterface - nFirstInterface;
 266     // possibly we are already at the end
 267     if ( nInterface >= _pInterfaces->size() )
 268         return 0;
 269
 270     // look for further matching func-defs within the same Interface
 271     SfxInterface* pInterface = (*_pInterfaces)[nInterface];
 272     while ( ++_nCurMsg < pInterface->Count() )
 273     {
 274         SfxSlot* pMsg = (*pInterface)[_nCurMsg];
 275         if ( pMsg->GetGroupId() == _pGroups->at(_nCurGroup) )
 276             return pMsg;
 277     }
 278
 279     return SeekSlot(++_nCurInterface );
 280 }
 281
 282
 283
 284 // Query SlotName with help text
 285
 286
 287 SfxInterface* SfxSlotPool::FirstInterface()
 288 {
 289     _nCurInterface = 0;
 290     if ( !_pInterfaces || !_pInterfaces->size() )
 291         return 0;
 292     return _pParentPool ? _pParentPool->FirstInterface() : (*_pInterfaces)[0];
 293 }
 294
 295
 296
 297
 298 const SfxSlot* SfxSlotPool::GetUnoSlot( const OUString& rName )
 299 {
 300     const SfxSlot *pSlot = NULL;
 301     for (sal_uInt16 nInterface = 0; _pInterfaces && nInterface < _pInterfaces->size(); ++nInterface)
 302     {
 303         pSlot = (*_pInterfaces)[nInterface]->GetSlot( rName );
 304         if ( pSlot )
 305             break;
 306     }
 307
 308     if ( !pSlot && _pParentPool )
 309         pSlot = _pParentPool->GetUnoSlot( rName );
 310
 311     return pSlot;
 312 }
 313
 314 SfxSlotPool& SfxSlotPool::GetSlotPool( SfxViewFrame *pFrame )
 315 {
 316     SfxModule *pMod = SfxModule::GetActiveModule( pFrame );
 317     if ( pMod && pMod->GetSlotPool() )
 318         return *pMod->GetSlotPool();
 319     else
 320         return *SfxGetpApp()->Get_Impl()->pSlotPool;
 321 }
 322
 323
 324 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */