svl/source/items/itempool.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
  21 #include <string.h>
  22 #include <stdio.h>
  23
  24 #include <svl/itempool.hxx>
  25 #include "whassert.hxx"
  26 #include <svl/brdcst.hxx>
  27 #include <svl/smplhint.hxx>
  28 #include "poolio.hxx"
  29
  30
  31 #if OSL_DEBUG_LEVEL > 0
  32 #include <map>
  33
  34 static void
  35 lcl_CheckSlots2(std::map<sal_uInt16, sal_uInt16> & rSlotMap,
  36         SfxItemPool const& rPool, SfxItemInfo const* pInfos)
  37 {
  38     if (!pInfos)
  39         return; // may not be initialized yet
  40     if (rPool.GetName() == "EditEngineItemPool")
  41         return; // HACK: this one has loads of duplicates already, ignore it :(
  42     sal_uInt16 const nFirst(rPool.GetFirstWhich());
  43     sal_uInt16 const nCount(rPool.GetLastWhich() - rPool.GetFirstWhich() + 1);
  44     for (sal_uInt16 n = 0; n < nCount; ++n)
  45     {
  46         sal_uInt16 const nSlotId(pInfos[n]._nSID);
  47         if (nSlotId != 0
  48             && nSlotId != 10883  // preexisting duplicate SID_ATTR_GRAF_CROP
  49             && nSlotId != 10024) // preexisting duplicate SID_ATTR_BORDER_OUTER
  50         {   // check for duplicate slot-id mapping
  51             std::map<sal_uInt16, sal_uInt16>::const_iterator const iter(
  52                 rSlotMap.find(nSlotId));
  53             sal_uInt16 const nWhich(nFirst + n);
  54             if (iter != rSlotMap.end())
  55             {
  56                 SAL_WARN("svl", "SfxItemPool: duplicate SlotId " << nSlotId
  57                         << " mapped to " << iter->second << " and " << nWhich);
  58                 assert(false);
  59             }
  60             rSlotMap.insert(std::make_pair(nSlotId, nWhich));
  61         }
  62     }
  63 }
  64
  65 #define CHECK_SLOTS() \
  66 do { \
  67     std::map<sal_uInt16, sal_uInt16> slotmap; \
  68     for (SfxItemPool * p = pImp->mpMaster; p; p = p->pImp->mpSecondary) \
  69     { \
  70         lcl_CheckSlots2(slotmap, *p, p->pItemInfos); \
  71     } \
  72 } while (false)
  73
  74 #else
  75 #define CHECK_SLOTS() do {} while (false)
  76 #endif
  77
  78
  79 void SfxItemPool::AddSfxItemPoolUser(SfxItemPoolUser& rNewUser)
  80 {
  81     pImp->maSfxItemPoolUsers.push_back(&rNewUser);
  82 }
  83
  84 void SfxItemPool::RemoveSfxItemPoolUser(SfxItemPoolUser& rOldUser)
  85 {
  86     const std::vector<SfxItemPoolUser*>::iterator aFindResult = ::std::find(
  87         pImp->maSfxItemPoolUsers.begin(), pImp->maSfxItemPoolUsers.end(), &rOldUser);
  88     if(aFindResult != pImp->maSfxItemPoolUsers.end())
  89     {
  90         pImp->maSfxItemPoolUsers.erase(aFindResult);
  91     }
  92 }
  93
  94 const SfxPoolItem* SfxItemPool::GetPoolDefaultItem( sal_uInt16 nWhich ) const
  95 {
  96     DBG_CHKTHIS(SfxItemPool, 0);
  97     const SfxPoolItem* pRet;
  98     if( IsInRange( nWhich ) )
  99         pRet = *(pImp->ppPoolDefaults + GetIndex_Impl( nWhich ));
 100     else if( pImp->mpSecondary )
 101         pRet = pImp->mpSecondary->GetPoolDefaultItem( nWhich );
 102     else
 103     {
 104         SFX_ASSERT( 0, nWhich, "unknown Which-Id - cannot get pool default" );
 105         pRet = 0;
 106     }
 107     return pRet;
 108 }
 109
 110 // -----------------------------------------------------------------------
 111
 112 bool SfxItemPool::IsItemFlag_Impl( sal_uInt16 nPos, sal_uInt16 nFlag ) const
 113 {
 114     sal_uInt16 nItemFlag = pItemInfos[nPos]._nFlags;
 115     return nFlag == (nItemFlag & nFlag);
 116 }
 117
 118 // -----------------------------------------------------------------------
 119
 120 bool SfxItemPool::IsItemFlag( sal_uInt16 nWhich, sal_uInt16 nFlag ) const
 121 {
 122     for ( const SfxItemPool *pPool = this; pPool; pPool = pPool->pImp->mpSecondary )
 123     {
 124         if ( pPool->IsInRange(nWhich) )
 125             return pPool->IsItemFlag_Impl( pPool->GetIndex_Impl(nWhich), nFlag);
 126     }
 127     DBG_ASSERT( !IsWhich(nWhich), "unknown which-id" );
 128     return sal_False;
 129 }
 130
 131 // -----------------------------------------------------------------------
 132
 133 SfxBroadcaster& SfxItemPool::BC()
 134 {
 135     return pImp->aBC;
 136 }
 137
 138 // -----------------------------------------------------------------------
 139
 140
 141 SfxItemPool::SfxItemPool
 142 (
 143     const OUString& rName,          /* Name des Pools zur Idetifikation
 144                                            im File-Format */
 145     sal_uInt16          nStartWhich,    /* erste Which-Id des Pools */
 146     sal_uInt16          nEndWhich,      /* letzte Which-Id des Pools */
 147     const SfxItemInfo*  pInfos,         /* SID-Map und Item-Flags */
 148     SfxPoolItem**       pDefaults,      /* Pointer auf statische Defaults,
 149                                            wird direkt vom Pool referenziert,
 150                                            jedoch kein Eigent"umer"ubergang */
 151     bool                bLoadRefCounts  /* Ref-Counts mitladen oder auf 1 setzen */
 152 ) :
 153
 154 /*  [Beschreibung]
 155
 156     Der im Normalfall verwendete Konstruktor der Klasse SfxItemPool. Es
 157     wird eine SfxItemPool-Instanz initialisiert, die Items im b"undigen
 158     Which-Bereich von 'nStartWhich' bis 'nEndWhich' verwalten kann.
 159
 160     F"ur jede dieser Which-Ids mu\s ein statischer Default im Array 'pDefaults'
 161     vorhanden sein, die dort beginnend mit einem <SfxPoolItem> mit der
 162     Which-Id 'nStartWhich' nach Which-Ids sortiert aufeinanderfolgend
 163     eingetragen sein m"ussen.
 164
 165     'pItemInfos' ist ein identisch angeordnetes Array von USHORTs, die
 166     Slot-Ids darstellen und Flags. Die Slot-Ids k"onnen 0 sein, wenn die
 167     betreffenden Items ausschlie\slich in der Core verwendet werden.
 168     "Uber die Flags kann z.B. bestimmt werden, ob Value-Sharing
 169     (SFX_ITEM_POOLABLE) stattfinden soll.
 170
 171     [Anmerkung]
 172
 173     Wenn der Pool <SfxSetItem>s enthalten soll, k"onnen im Konstruktor noch
 174     keine static-Defaults angegeben werden. Dies mu\s dann nachtr"aglich
 175     mit <SfxItemPool::SetDefaults(SfxItemPool**)> geschehen.
 176
 177
 178     [Querverweise]
 179
 180     <SfxItemPool::SetDefaults(SfxItemPool**)>
 181     <SfxItemPool::ReleaseDefaults(SfxPoolItem**,sal_uInt16,sal_Bool)>
 182     <SfxItemPool::ReldaseDefaults(sal_Bool)>
 183 */
 184
 185     pItemInfos(pInfos),
 186     pImp( new SfxItemPool_Impl( this, rName, nStartWhich, nEndWhich ) )
 187 {
 188     DBG_CTOR(SfxItemPool, 0);
 189
 190     pImp->eDefMetric = SFX_MAPUNIT_TWIP;
 191     pImp->nVersion = 0;
 192     pImp->bStreaming = false;
 193     pImp->nLoadingVersion = 0;
 194     pImp->nInitRefCount = 1;
 195     pImp->nVerStart = pImp->mnStart;
 196     pImp->nVerEnd = pImp->mnEnd;
 197     pImp->bInSetItem = false;
 198     pImp->nStoringStart = nStartWhich;
 199     pImp->nStoringEnd = nEndWhich;
 200     pImp->mbPersistentRefCounts = bLoadRefCounts;
 201
 202     if ( pDefaults )
 203         SetDefaults(pDefaults);
 204 }
 205
 206 // -----------------------------------------------------------------------
 207
 208
 209 SfxItemPool::SfxItemPool
 210 (
 211     const SfxItemPool&  rPool,                  //  von dieser Instanz kopieren
 212     sal_Bool                bCloneStaticDefaults    /*  sal_True
 213                                                     statische Defaults kopieren
 214
 215                                                     sal_False
 216                                                     statische Defaults
 217                                                     "ubernehehmen */
 218 ) :
 219
 220 /*  [Beschreibung]
 221
 222     Copy-Konstruktor der Klasse SfxItemPool.
 223
 224
 225     [Querverweise]
 226
 227     <SfxItemPool::Clone()const>
 228 */
 229
 230     pItemInfos(rPool.pItemInfos),
 231     pImp( new SfxItemPool_Impl( this, rPool.pImp->aName, rPool.pImp->mnStart, rPool.pImp->mnEnd ) )
 232 {
 233     DBG_CTOR(SfxItemPool, 0);
 234     pImp->eDefMetric = rPool.pImp->eDefMetric;
 235     pImp->nVersion = rPool.pImp->nVersion;
 236     pImp->bStreaming = sal_False;
 237     pImp->nLoadingVersion = 0;
 238     pImp->nInitRefCount = 1;
 239     pImp->nVerStart = rPool.pImp->nVerStart;
 240     pImp->nVerEnd = rPool.pImp->nVerEnd;
 241     pImp->bInSetItem = false;
 242     pImp->nStoringStart = pImp->mnStart;
 243     pImp->nStoringEnd = pImp->mnEnd;
 244     pImp->mbPersistentRefCounts = rPool.pImp->mbPersistentRefCounts;
 245
 246     // Static Defaults "ubernehmen
 247     if ( bCloneStaticDefaults )
 248     {
 249         SfxPoolItem **ppDefaults = new SfxPoolItem*[pImp->mnEnd-pImp->mnStart+1];
 250         for ( sal_uInt16 n = 0; n <= pImp->mnEnd - pImp->mnStart; ++n )
 251         {
 252             (*( ppDefaults + n )) = (*( rPool.pImp->ppStaticDefaults + n ))->Clone(this);
 253             (*( ppDefaults + n ))->SetKind( SFX_ITEMS_STATICDEFAULT );
 254         }
 255
 256         SetDefaults( ppDefaults );
 257     }
 258     else
 259         SetDefaults( rPool.pImp->ppStaticDefaults );
 260
 261     // Pool Defaults kopieren
 262     for ( sal_uInt16 n = 0; n <= pImp->mnEnd - pImp->mnStart; ++n )
 263         if ( (*( rPool.pImp->ppPoolDefaults + n )) )
 264         {
 265             (*( pImp->ppPoolDefaults + n )) = (*( rPool.pImp->ppPoolDefaults + n ))->Clone(this);
 266             (*( pImp->ppPoolDefaults + n ))->SetKind( SFX_ITEMS_POOLDEFAULT );
 267         }
 268
 269     // Copy Version-Map
 270     for ( size_t nVer = 0; nVer < rPool.pImp->aVersions.size(); ++nVer )
 271     {
 272         const SfxPoolVersion_ImplPtr pOld = rPool.pImp->aVersions[nVer];
 273         SfxPoolVersion_ImplPtr pNew = SfxPoolVersion_ImplPtr( new SfxPoolVersion_Impl( *pOld ) );
 274         pImp->aVersions.push_back( pNew );
 275     }
 276
 277     // Verkettung wiederherstellen
 278     if ( rPool.pImp->mpSecondary )
 279         SetSecondaryPool( rPool.pImp->mpSecondary->Clone() );
 280 }
 281
 282 // -----------------------------------------------------------------------
 283
 284 void SfxItemPool::SetDefaults( SfxPoolItem **pDefaults )
 285 {
 286     DBG_CHKTHIS(SfxItemPool, 0);
 287     DBG_ASSERT( pDefaults, "erst wollen, dann nichts geben..." );
 288     DBG_ASSERT( !pImp->ppStaticDefaults, "habe schon defaults" );
 289
 290     pImp->ppStaticDefaults = pDefaults;
 291     //! if ( (*ppStaticDefaults)->GetKind() != SFX_ITEMS_STATICDEFAULT )
 292     //! geht wohl nicht im Zshg mit SetItems, die hinten stehen
 293     {
 294         DBG_ASSERT( (*pImp->ppStaticDefaults)->GetRefCount() == 0 ||
 295                     IsDefaultItem( (*pImp->ppStaticDefaults) ),
 296                     "das sind keine statics" );
 297         for ( sal_uInt16 n = 0; n <= pImp->mnEnd - pImp->mnStart; ++n )
 298         {
 299             SFX_ASSERT( (*( pImp->ppStaticDefaults + n ))->Which() == n + pImp->mnStart,
 300                         n + pImp->mnStart, "static defaults not sorted" );
 301             (*( pImp->ppStaticDefaults + n ))->SetKind( SFX_ITEMS_STATICDEFAULT );
 302             DBG_ASSERT( !(pImp->maPoolItems[n]), "defaults with setitems with items?!" );
 303         }
 304     }
 305 }
 306
 307 // -----------------------------------------------------------------------
 308
 309 void SfxItemPool::ReleaseDefaults
 310 (
 311     sal_Bool    bDelete     /*  sal_True
 312                             l"oscht sowohl das Array als auch die einzelnen
 313                             statischen Defaults
 314
 315                             sal_False
 316                             l"oscht weder das Array noch die einzelnen
 317                             statischen Defaults */
 318 )
 319
 320 /*  [Beschreibung]
 321
 322     Gibt die statischen Defaults der betreffenden SfxItemPool-Instanz frei
 323     und l"oscht ggf. die statischen Defaults.
 324
 325     Nach Aufruf dieser Methode darf die SfxItemPool-Instanz nicht mehr
 326     verwendet werden, einzig ist der Aufruf des Destruktors zu"lassig.
 327 */
 328
 329 {
 330     DBG_ASSERT( pImp->ppStaticDefaults, "keine Arme keine Kekse" );
 331     ReleaseDefaults( pImp->ppStaticDefaults, pImp->mnEnd - pImp->mnStart + 1, bDelete );
 332
 333     // KSO (22.10.98): ppStaticDefaults zeigt auf geloeschten Speicher,
 334     // wenn bDelete == sal_True.
 335     if ( bDelete )
 336         pImp->ppStaticDefaults = 0;
 337 }
 338
 339 // -----------------------------------------------------------------------
 340
 341 void SfxItemPool::ReleaseDefaults
 342 (
 343     SfxPoolItem**   pDefaults,  /*  freizugebende statische Defaults */
 344
 345     sal_uInt16          nCount,     /*  Anzahl der statischen Defaults */
 346
 347     sal_Bool            bDelete     /*  sal_True
 348                                     l"oscht sowohl das Array als auch die
 349                                     einzelnen statischen Defaults
 350
 351                                     sal_False
 352                                     l"oscht weder das Array noch die
 353                                     einzelnen statischen Defaults */
 354 )
 355
 356 /*  [Beschreibung]
 357
 358     Gibt die angegebenen statischen Defaults frei und l"oscht ggf.
 359     die statischen Defaults.
 360
 361     Diese Methode darf erst nach Zerst"orung aller SfxItemPool-Instanzen,
 362     welche die angegebenen statischen Defaults 'pDefault' verwenden,
 363     aufgerufen werden.
 364 */
 365
 366 {
 367     DBG_ASSERT( pDefaults, "erst wollen, dann nichts geben..." );
 368
 369     for ( sal_uInt16 n = 0; n < nCount; ++n )
 370     {
 371         SFX_ASSERT( IsStaticDefaultItem( *(pDefaults+n) ),
 372                     n, "das ist kein static-default" );
 373         (*( pDefaults + n ))->SetRefCount( 0 );
 374         if ( bDelete )
 375             { delete *( pDefaults + n ); *(pDefaults + n) = 0; }
 376     }
 377
 378     if ( bDelete )
 379         { delete[] pDefaults; pDefaults = 0; }
 380 }
 381
 382 // -----------------------------------------------------------------------
 383
 384 SfxItemPool::~SfxItemPool()
 385 {
 386     DBG_DTOR(SfxItemPool, 0);
 387
 388     if ( !pImp->maPoolItems.empty() && pImp->ppPoolDefaults )
 389         Delete();
 390
 391     if (pImp->mpMaster != NULL && pImp->mpMaster != this)
 392     {
 393         // This condition indicates an error.  A
 394         // pImp->mpMaster->SetSecondaryPool(...) call should have been made
 395         // earlier to prevent this.  At this point we can only try to
 396         // prevent a crash later on.
 397         DBG_ASSERT( pImp->mpMaster == this, "destroying active Secondary-Pool" );
 398         if (pImp->mpMaster->pImp->mpSecondary == this)
 399             pImp->mpMaster->pImp->mpSecondary = NULL;
 400     }
 401
 402     delete pImp;
 403 }
 404
 405 void SfxItemPool::Free(SfxItemPool* pPool)
 406 {
 407     if(pPool)
 408     {
 409         // tell all the registered SfxItemPoolUsers that the pool is in destruction
 410         std::vector<SfxItemPoolUser*> aListCopy(pPool->pImp->maSfxItemPoolUsers.begin(), pPool->pImp->maSfxItemPoolUsers.end());
 411         for(std::vector<SfxItemPoolUser*>::iterator aIterator = aListCopy.begin(); aIterator != aListCopy.end(); ++aIterator)
 412         {
 413             SfxItemPoolUser* pSfxItemPoolUser = *aIterator;
 414             DBG_ASSERT(pSfxItemPoolUser, "corrupt SfxItemPoolUser list (!)");
 415             pSfxItemPoolUser->ObjectInDestruction(*pPool);
 416         }
 417
 418         // Clear the vector. This means that user do not need to call RemoveSfxItemPoolUser()
 419         // when they get called from ObjectInDestruction().
 420         pPool->pImp->maSfxItemPoolUsers.clear();
 421
 422         // delete pool
 423         delete pPool;
 424     }
 425 }
 426
 427 // -----------------------------------------------------------------------
 428
 429
 430 void SfxItemPool::SetSecondaryPool( SfxItemPool *pPool )
 431 {
 432     // ggf. an abgeh"angten Pools den Master zur"ucksetzen
 433     if ( pImp->mpSecondary )
 434     {
 435 #ifdef DBG_UTIL
 436         SAL_INFO( "svl.items", "fuer Image, dort gibt es derzeit keine Statics - Bug" );
 437         if ( pImp->ppStaticDefaults )
 438         {
 439             // Delete() ist noch nicht gelaufen?
 440             if ( !pImp->maPoolItems.empty() && !pImp->mpSecondary->pImp->maPoolItems.empty() )
 441             {
 442                 // hat der master SetItems?
 443                 bool bHasSetItems = false;
 444                 for ( sal_uInt16 i = 0; !bHasSetItems && i < pImp->mnEnd - pImp->mnStart; ++i )
 445                     bHasSetItems = pImp->ppStaticDefaults[i]->ISA(SfxSetItem);
 446
 447                 // abgehaengte Pools muessen leer sein
 448                 bool bOK = bHasSetItems;
 449                 for ( sal_uInt16 n = 0;
 450                       bOK && n <= pImp->mpSecondary->pImp->mnEnd - pImp->mpSecondary->pImp->mnStart;
 451                       ++n )
 452                 {
 453                     SfxPoolItemArray_Impl* pItemArr = pImp->mpSecondary->pImp->maPoolItems[n];
 454                     if ( pItemArr )
 455                     {
 456                         SfxPoolItemArrayBase_Impl::iterator ppHtArr =   pItemArr->begin();
 457                         for( size_t i = pItemArr->size(); i; ++ppHtArr, --i )
 458                             if ( !(*ppHtArr) )
 459                             {
 460                                 OSL_FAIL( "old secondary pool must be empty" );
 461                                 bOK = false;
 462                                 break;
 463                             }
 464                     }
 465                 }
 466             }
 467         }
 468 #endif
 469
 470         pImp->mpSecondary->pImp->mpMaster = pImp->mpSecondary;
 471         for ( SfxItemPool *p = pImp->mpSecondary->pImp->mpSecondary; p; p = p->pImp->mpSecondary )
 472             p->pImp->mpMaster = pImp->mpSecondary;
 473     }
 474
 475     // ggf. den Master der neuen Secondary-Pools setzen
 476     DBG_ASSERT( !pPool || pPool->pImp->mpMaster == pPool, "Secondary tanzt auf zwei Hochzeiten " );
 477     SfxItemPool *pNewMaster = pImp->mpMaster ? pImp->mpMaster : this;
 478     for ( SfxItemPool *p = pPool; p; p = p->pImp->mpSecondary )
 479         p->pImp->mpMaster = pNewMaster;
 480
 481     // neuen Secondary-Pool merken
 482     pImp->mpSecondary = pPool;
 483
 484     CHECK_SLOTS();
 485 }
 486
 487 void SfxItemPool::SetItemInfos(SfxItemInfo const*const pInfos)
 488 {
 489     pItemInfos = pInfos;
 490     CHECK_SLOTS();
 491 }
 492
 493 // -----------------------------------------------------------------------
 494
 495 SfxMapUnit SfxItemPool::GetMetric( sal_uInt16 ) const
 496 {
 497     DBG_CHKTHIS(SfxItemPool, 0);
 498
 499     return pImp->eDefMetric;
 500 }
 501
 502 // -----------------------------------------------------------------------
 503
 504 void SfxItemPool::SetDefaultMetric( SfxMapUnit eNewMetric )
 505 {
 506     DBG_CHKTHIS(SfxItemPool, 0);
 507
 508     pImp->eDefMetric = eNewMetric;
 509 }
 510
 511 const OUString& SfxItemPool::GetName() const
 512 {
 513     return pImp->aName;
 514 }
 515
 516 // -----------------------------------------------------------------------
 517
 518 SfxItemPresentation SfxItemPool::GetPresentation
 519 (
 520     const SfxPoolItem&  rItem,
 521     SfxItemPresentation ePresent,
 522     SfxMapUnit          eMetric,
 523     OUString&           rText,
 524     const IntlWrapper * pIntlWrapper
 525 )   const
 526 {
 527     DBG_CHKTHIS(SfxItemPool, 0);
 528     return rItem.GetPresentation(
 529         ePresent, GetMetric(rItem.Which()), eMetric, rText, pIntlWrapper );
 530 }
 531
 532
 533 // -----------------------------------------------------------------------
 534
 535 SfxItemPool* SfxItemPool::Clone() const
 536 {
 537     DBG_CHKTHIS(SfxItemPool, 0);
 538
 539     SfxItemPool *pPool = new SfxItemPool( *this );
 540     return pPool;
 541 }
 542
 543 // ----------------------------------------------------------------------
 544
 545 void SfxItemPool::Delete()
 546 {
 547     DBG_CHKTHIS(SfxItemPool, 0);
 548
 549     // schon deleted?
 550     if ( pImp->maPoolItems.empty() || !pImp->ppPoolDefaults )
 551         return;
 552
 553     // z.B. laufenden Requests bescheidsagen
 554     pImp->aBC.Broadcast( SfxSimpleHint( SFX_HINT_DYING ) );
 555
 556     //MA 16. Apr. 97: Zweimal durchlaufen, in der ersten Runde fuer die SetItems.
 557     //Der Klarheit halber wird das jetzt in zwei besser lesbare Schleifen aufgeteilt.
 558
 559     std::vector<SfxPoolItemArray_Impl*>::iterator itrItemArr = pImp->maPoolItems.begin();
 560     SfxPoolItem** ppDefaultItem = pImp->ppPoolDefaults;
 561     SfxPoolItem** ppStaticDefaultItem = pImp->ppStaticDefaults;
 562     sal_uInt16 nArrCnt;
 563
 564     //Erst die SetItems abraeumen
 565     SAL_INFO( "svl.items", "fuer Image, dort gibt es derzeit keine Statics - Bug" );
 566     if ( pImp->ppStaticDefaults )
 567     {
 568         for ( nArrCnt = GetSize_Impl();
 569                 nArrCnt;
 570                 --nArrCnt, ++itrItemArr, ++ppDefaultItem, ++ppStaticDefaultItem )
 571         {
 572             // KSO (22.10.98): *ppStaticDefaultItem kann im dtor einer
 573             // von SfxItemPool abgeleiteten Klasse bereits geloescht worden
 574             // sein! -> CHAOS Itempool
 575             if ( *ppStaticDefaultItem && (*ppStaticDefaultItem)->ISA(SfxSetItem) )
 576             {
 577                 if ( *itrItemArr )
 578                 {
 579                     SfxPoolItemArrayBase_Impl::iterator ppHtArr = (*itrItemArr)->begin();
 580                     for ( size_t n = (*itrItemArr)->size(); n; --n, ++ppHtArr )
 581                         if (*ppHtArr)
 582                         {
 583 #ifdef DBG_UTIL
 584                             ReleaseRef( **ppHtArr, (*ppHtArr)->GetRefCount() );
 585 #endif
 586                             delete *ppHtArr;
 587                         }
 588                     DELETEZ( *itrItemArr );
 589                 }
 590                 if ( *ppDefaultItem )
 591                 {
 592 #ifdef DBG_UTIL
 593                     SetRefCount( **ppDefaultItem, 0 );
 594 #endif
 595                     DELETEZ( *ppDefaultItem );
 596                 }
 597             }
 598         }
 599     }
 600
 601     itrItemArr = pImp->maPoolItems.begin();
 602     ppDefaultItem = pImp->ppPoolDefaults;
 603
 604     //Jetzt die 'einfachen' Items
 605     for ( nArrCnt = GetSize_Impl();
 606             nArrCnt;
 607             --nArrCnt, ++itrItemArr, ++ppDefaultItem )
 608     {
 609         if ( *itrItemArr )
 610         {
 611             SfxPoolItemArrayBase_Impl::iterator ppHtArr = (*itrItemArr)->begin();
 612             for ( size_t n = (*itrItemArr)->size(); n; --n, ++ppHtArr )
 613                 if (*ppHtArr)
 614                 {
 615 #ifdef DBG_UTIL
 616                     ReleaseRef( **ppHtArr, (*ppHtArr)->GetRefCount() );
 617 #endif
 618                     delete *ppHtArr;
 619                 }
 620             DELETEZ( *itrItemArr );
 621         }
 622         if ( *ppDefaultItem )
 623         {
 624 #ifdef DBG_UTIL
 625             SetRefCount( **ppDefaultItem, 0 );
 626 #endif
 627             delete *ppDefaultItem;
 628         }
 629     }
 630
 631     pImp->DeleteItems();
 632 }
 633
 634 // ----------------------------------------------------------------------
 635
 636 void SfxItemPool::SetPoolDefaultItem(const SfxPoolItem &rItem)
 637 {
 638     DBG_CHKTHIS(SfxItemPool, 0);
 639     if ( IsInRange(rItem.Which()) )
 640     {
 641         SfxPoolItem **ppOldDefault =
 642             pImp->ppPoolDefaults + GetIndex_Impl(rItem.Which());
 643         SfxPoolItem *pNewDefault = rItem.Clone(this);
 644         pNewDefault->SetKind(SFX_ITEMS_POOLDEFAULT);
 645         if ( *ppOldDefault )
 646         {
 647             (*ppOldDefault)->SetRefCount(0);
 648             DELETEZ( *ppOldDefault );
 649         }
 650         *ppOldDefault = pNewDefault;
 651     }
 652     else if ( pImp->mpSecondary )
 653         pImp->mpSecondary->SetPoolDefaultItem(rItem);
 654     else
 655     {
 656         SFX_ASSERT( 0, rItem.Which(), "unknown Which-Id - cannot set pool default" );
 657     }
 658 }
 659
 660 /*
 661  * Resets the default of the given <Which-Id> back to the static default.
 662  * If a pool default exists it is removed.
 663  */
 664 void SfxItemPool::ResetPoolDefaultItem( sal_uInt16 nWhichId )
 665 {
 666     DBG_CHKTHIS(SfxItemPool, 0);
 667     if ( IsInRange(nWhichId) )
 668     {
 669         SfxPoolItem **ppOldDefault =
 670             pImp->ppPoolDefaults + GetIndex_Impl( nWhichId );
 671         if ( *ppOldDefault )
 672         {
 673             (*ppOldDefault)->SetRefCount(0);
 674             DELETEZ( *ppOldDefault );
 675         }
 676     }
 677     else if ( pImp->mpSecondary )
 678         pImp->mpSecondary->ResetPoolDefaultItem(nWhichId);
 679     else
 680     {
 681         SFX_ASSERT( 0, nWhichId, "unknown Which-Id - cannot set pool default" );
 682     }
 683 }
 684
 685 // -----------------------------------------------------------------------
 686
 687 const SfxPoolItem& SfxItemPool::Put( const SfxPoolItem& rItem, sal_uInt16 nWhich )
 688 {
 689     DBG_ASSERT( !rItem.ISA(SfxSetItem) ||
 690                 0 != &((const SfxSetItem&)rItem).GetItemSet(),
 691                 "SetItem without ItemSet" );
 692
 693     DBG_CHKTHIS(SfxItemPool, 0);
 694     if ( 0 == nWhich )
 695         nWhich = rItem.Which();
 696
 697     // richtigen Secondary-Pool finden
 698     bool bSID = nWhich > SFX_WHICH_MAX;
 699     if ( !bSID && !IsInRange(nWhich) )
 700     {
 701         if ( pImp->mpSecondary )
 702             return pImp->mpSecondary->Put( rItem, nWhich );
 703         OSL_FAIL( "unknown Which-Id - cannot put item" );
 704     }
 705
 706     // SID oder nicht poolable (neue Definition)?
 707     sal_uInt16 nIndex = bSID ? USHRT_MAX : GetIndex_Impl(nWhich);
 708     if ( USHRT_MAX == nIndex ||
 709          IsItemFlag_Impl( nIndex, SFX_ITEM_NOT_POOLABLE ) )
 710     {
 711         SFX_ASSERT( USHRT_MAX != nIndex || rItem.Which() != nWhich ||
 712                     !IsDefaultItem(&rItem) || rItem.GetKind() == SFX_ITEMS_DELETEONIDLE,
 713                     nWhich, "ein nicht Pool-Item ist Default?!" );
 714         SfxPoolItem *pPoolItem = rItem.Clone(pImp->mpMaster);
 715         pPoolItem->SetWhich(nWhich);
 716         AddRef( *pPoolItem );
 717         return *pPoolItem;
 718     }
 719
 720     SFX_ASSERT( rItem.IsA(GetDefaultItem(nWhich).Type()), nWhich,
 721                 "SFxItemPool: wrong item type in Put" );
 722
 723     SfxPoolItemArray_Impl* pItemArr = pImp->maPoolItems[nIndex];
 724     if (!pItemArr)
 725     {
 726         pImp->maPoolItems[nIndex] = new SfxPoolItemArray_Impl;
 727         pItemArr = pImp->maPoolItems[nIndex];
 728     }
 729
 730     SfxPoolItemArrayBase_Impl::iterator ppFree;
 731     bool ppFreeIsSet = false;
 732     if ( IsItemFlag_Impl( nIndex, SFX_ITEM_POOLABLE ) )
 733     {
 734         // wenn es ueberhaupt gepoolt ist, koennte es schon drin sein
 735         if ( IsPooledItem(&rItem) )
 736         {
 737             // 1. Schleife: teste ob der Pointer vorhanden ist.
 738             SfxPoolItemArrayBase_Impl::iterator itr =
 739                 std::find(pItemArr->begin(), pItemArr->end(), &rItem);
 740             if (itr != pItemArr->end())
 741             {
 742                 AddRef(**itr);
 743                 return **itr;
 744             }
 745         }
 746
 747         // 2. Schleife: dann muessen eben die Attribute verglichen werden
 748         SfxPoolItemArrayBase_Impl::iterator itr = pItemArr->begin();
 749         for (; itr != pItemArr->end(); ++itr)
 750         {
 751             if (*itr)
 752             {
 753                 if (**itr == rItem)
 754                 {
 755                     AddRef(**itr);
 756                     return **itr;
 757                 }
 758             }
 759             else
 760             {
 761                 if (!ppFreeIsSet)
 762                 {
 763                     ppFree = itr;
 764                     ppFreeIsSet = true;
 765                 }
 766             }
 767         }
 768     }
 769     else
 770     {
 771         // freien Platz suchen
 772         SfxPoolItemArrayBase_Impl::iterator itr = pItemArr->begin();
 773         std::advance(itr, pItemArr->nFirstFree);
 774         for (; itr != pItemArr->end(); ++itr)
 775         {
 776             if (!*itr)
 777             {
 778                 ppFree = itr;
 779                 ppFreeIsSet = true;
 780                 break;
 781             }
 782         }
 783         // naechstmoeglichen freien Platz merken
 784         pItemArr->nFirstFree = std::distance(pItemArr->begin(), itr);
 785     }
 786
 787     // nicht vorhanden, also im PtrArray eintragen
 788     SfxPoolItem* pNewItem = rItem.Clone(pImp->mpMaster);
 789     pNewItem->SetWhich(nWhich);
 790 #ifdef DBG_UTIL
 791     SFX_ASSERT( rItem.Type() == pNewItem->Type(), nWhich, "unequal types in Put(): no Clone()?" )
 792     if ( !rItem.ISA(SfxSetItem) )
 793     {
 794         SFX_ASSERT( !IsItemFlag(nWhich, SFX_ITEM_POOLABLE) ||
 795                     rItem == *pNewItem,
 796                     nWhich, "unequal items in Put(): no operator==?" );
 797         SFX_ASSERT( !IsItemFlag(*pNewItem, SFX_ITEM_POOLABLE) ||
 798                     *pNewItem == rItem,
 799                     nWhich, "unequal items in Put(): no operator==?" );
 800     }
 801 #endif
 802     AddRef( *pNewItem, pImp->nInitRefCount );
 803
 804     if ( ppFreeIsSet == false )
 805         pItemArr->push_back( pNewItem );
 806     else
 807     {
 808         DBG_ASSERT( *ppFree == 0, "using surrogate in use" );
 809         *ppFree = pNewItem;
 810     }
 811     return *pNewItem;
 812 }
 813
 814 // -----------------------------------------------------------------------
 815
 816 void SfxItemPool::Remove( const SfxPoolItem& rItem )
 817 {
 818     DBG_CHKTHIS(SfxItemPool, 0);
 819
 820     DBG_ASSERT( !rItem.ISA(SfxSetItem) ||
 821                 0 != &((const SfxSetItem&)rItem).GetItemSet(),
 822                 "SetItem without ItemSet" );
 823
 824     SFX_ASSERT( !IsPoolDefaultItem(&rItem), rItem.Which(),
 825                 "wo kommt denn hier ein Pool-Default her" );
 826
 827     // richtigen Secondary-Pool finden
 828     const sal_uInt16 nWhich = rItem.Which();
 829     bool bSID = nWhich > SFX_WHICH_MAX;
 830     if ( !bSID && !IsInRange(nWhich) )
 831     {
 832         if ( pImp->mpSecondary )
 833         {
 834             pImp->mpSecondary->Remove( rItem );
 835             return;
 836         }
 837         OSL_FAIL( "unknown Which-Id - cannot remove item" );
 838     }
 839
 840     // SID oder nicht poolable (neue Definition)?
 841     sal_uInt16 nIndex = bSID ? USHRT_MAX : GetIndex_Impl(nWhich);
 842     if ( bSID || IsItemFlag_Impl( nIndex, SFX_ITEM_NOT_POOLABLE ) )
 843     {
 844         SFX_ASSERT( USHRT_MAX != nIndex ||
 845                     !IsDefaultItem(&rItem), rItem.Which(),
 846                     "ein nicht Pool-Item ist Default?!" );
 847         if ( 0 == ReleaseRef(rItem) )
 848         {
 849             SfxPoolItem *pItem = &(SfxPoolItem &)rItem;
 850             delete pItem;
 851         }
 852         return;
 853     }
 854
 855     SFX_ASSERT( rItem.GetRefCount(), rItem.Which(), "RefCount == 0, Remove unmoeglich" );
 856
 857     // statische Defaults sind eben einfach da
 858     if ( rItem.GetKind() == SFX_ITEMS_STATICDEFAULT &&
 859          &rItem == *( pImp->ppStaticDefaults + GetIndex_Impl(nWhich) ) )
 860         return;
 861
 862     // Item im eigenen Pool suchen
 863     SfxPoolItemArray_Impl* pItemArr = pImp->maPoolItems[nIndex];
 864     SFX_ASSERT( pItemArr, rItem.Which(), "removing Item not in Pool" );
 865     SfxPoolItemArrayBase_Impl::iterator ppHtArrBeg = pItemArr->begin(), ppHtArrEnd = pItemArr->end();
 866     for (SfxPoolItemArrayBase_Impl::iterator ppHtArr = ppHtArrBeg; ppHtArr != ppHtArrEnd; ++ppHtArr)
 867     {
 868         SfxPoolItem*& p = *ppHtArr;
 869         if (p == &rItem)
 870         {
 871             if ( p->GetRefCount() ) //!
 872                 ReleaseRef( *p );
 873             else
 874             {
 875                 SFX_ASSERT( 0, rItem.Which(), "removing Item without ref" );
 876             }
 877
 878             // ggf. kleinstmoegliche freie Position merken
 879             size_t nPos = std::distance(ppHtArrBeg, ppHtArr);
 880             if ( pItemArr->nFirstFree > nPos )
 881                 pItemArr->nFirstFree = nPos;
 882
 883             //! MI: Hack, solange wir das Problem mit dem Outliner haben
 884             //! siehe anderes MI-REF
 885             if ( 0 == p->GetRefCount() && nWhich < 4000 )
 886                 DELETEZ(p);
 887             return;
 888         }
 889     }
 890
 891     // nicht vorhanden
 892     SFX_ASSERT( 0, rItem.Which(), "removing Item not in Pool" );
 893 }
 894
 895 // -----------------------------------------------------------------------
 896
 897 const SfxPoolItem& SfxItemPool::GetDefaultItem( sal_uInt16 nWhich ) const
 898 {
 899     DBG_CHKTHIS(SfxItemPool, 0);
 900
 901     if ( !IsInRange(nWhich) )
 902     {
 903         if ( pImp->mpSecondary )
 904             return pImp->mpSecondary->GetDefaultItem( nWhich );
 905         SFX_ASSERT( 0, nWhich, "unknown which - dont ask me for defaults" );
 906     }
 907
 908     DBG_ASSERT( pImp->ppStaticDefaults, "no defaults known - dont ask me for defaults" );
 909     sal_uInt16 nPos = GetIndex_Impl(nWhich);
 910     SfxPoolItem *pDefault = *(pImp->ppPoolDefaults + nPos);
 911     if ( pDefault )
 912         return *pDefault;
 913     return **(pImp->ppStaticDefaults + nPos);
 914 }
 915
 916 SfxItemPool* SfxItemPool::GetSecondaryPool() const
 917 {
 918     return pImp->mpSecondary;
 919 }
 920
 921 SfxItemPool* SfxItemPool::GetMasterPool() const
 922 {
 923     return pImp->mpMaster;
 924 }
 925
 926 void SfxItemPool::FreezeIdRanges()
 927
 928 /*  [Beschreibung]
 929
 930     This method should be called at the master pool, when all secondary
 931     pools are appended to it.
 932
 933     It calculates the ranges of 'which-ids' for fast construction of
 934     item-sets, which contains all 'which-ids'.
 935 */
 936
 937 {
 938     FillItemIdRanges_Impl( pImp->mpPoolRanges );
 939 }
 940
 941
 942 // -----------------------------------------------------------------------
 943
 944 void SfxItemPool::FillItemIdRanges_Impl( sal_uInt16*& pWhichRanges ) const
 945 {
 946     DBG_CHKTHIS(SfxItemPool, 0);
 947     DBG_ASSERT( !pImp->mpPoolRanges, "GetFrozenRanges() would be faster!" );
 948
 949     const SfxItemPool *pPool;
 950     sal_uInt16 nLevel = 0;
 951     for( pPool = this; pPool; pPool = pPool->pImp->mpSecondary )
 952         ++nLevel;
 953
 954     pWhichRanges = new sal_uInt16[ 2*nLevel + 1 ];
 955
 956     nLevel = 0;
 957     for( pPool = this; pPool; pPool = pPool->pImp->mpSecondary )
 958     {
 959         *(pWhichRanges+(nLevel++)) = pPool->pImp->mnStart;
 960         *(pWhichRanges+(nLevel++)) = pPool->pImp->mnEnd;
 961         *(pWhichRanges+nLevel) = 0;
 962     }
 963 }
 964
 965 const sal_uInt16* SfxItemPool::GetFrozenIdRanges() const
 966 {
 967     return pImp->mpPoolRanges;
 968 }
 969
 970 const SfxPoolItem *SfxItemPool::GetItem2(sal_uInt16 nWhich, sal_uInt32 nOfst) const
 971 {
 972     DBG_CHKTHIS(SfxItemPool, 0);
 973
 974     if ( !IsInRange(nWhich) )
 975     {
 976         if ( pImp->mpSecondary )
 977             return pImp->mpSecondary->GetItem2( nWhich, nOfst );
 978         SFX_ASSERT( 0, nWhich, "unknown Which-Id - cannot resolve surrogate" );
 979         return 0;
 980     }
 981
 982     // dflt-Attribut?
 983     if ( nOfst == SFX_ITEMS_DEFAULT )
 984         return *(pImp->ppStaticDefaults + GetIndex_Impl(nWhich));
 985
 986     SfxPoolItemArray_Impl* pItemArr = pImp->maPoolItems[GetIndex_Impl(nWhich)];
 987     if( pItemArr && nOfst < pItemArr->size() )
 988         return (*pItemArr)[nOfst];
 989
 990     return 0;
 991 }
 992
 993 // -----------------------------------------------------------------------
 994
 995 sal_uInt32 SfxItemPool::GetItemCount2(sal_uInt16 nWhich) const
 996 {
 997     DBG_CHKTHIS(SfxItemPool, 0);
 998
 999     if ( !IsInRange(nWhich) )
1000     {
1001         if ( pImp->mpSecondary )
1002             return pImp->mpSecondary->GetItemCount2( nWhich );
1003         SFX_ASSERT( 0, nWhich, "unknown Which-Id - cannot resolve surrogate" );
1004         return 0;
1005     }
1006
1007     SfxPoolItemArray_Impl* pItemArr = pImp->maPoolItems[GetIndex_Impl(nWhich)];
1008     if  ( pItemArr )
1009         return pItemArr->size();
1010     return 0;
1011 }
1012
1013 // -----------------------------------------------------------------------
1014
1015 sal_uInt16 SfxItemPool::GetWhich( sal_uInt16 nSlotId, sal_Bool bDeep ) const
1016 {
1017     if ( !IsSlot(nSlotId) )
1018         return nSlotId;
1019
1020     sal_uInt16 nCount = pImp->mnEnd - pImp->mnStart + 1;
1021     for ( sal_uInt16 nOfs = 0; nOfs < nCount; ++nOfs )
1022         if ( pItemInfos[nOfs]._nSID == nSlotId )
1023             return nOfs + pImp->mnStart;
1024     if ( pImp->mpSecondary && bDeep )
1025         return pImp->mpSecondary->GetWhich(nSlotId);
1026     return nSlotId;
1027 }
1028
1029 // -----------------------------------------------------------------------
1030
1031 sal_uInt16 SfxItemPool::GetSlotId( sal_uInt16 nWhich, sal_Bool bDeep ) const
1032 {
1033     if ( !IsWhich(nWhich) )
1034         return nWhich;
1035
1036     if ( !IsInRange( nWhich ) )
1037     {
1038         if ( pImp->mpSecondary && bDeep )
1039             return pImp->mpSecondary->GetSlotId(nWhich);
1040         SFX_ASSERT( 0, nWhich, "unknown Which-Id - cannot get slot-id" );
1041         return 0;
1042     }
1043
1044     sal_uInt16 nSID = pItemInfos[nWhich - pImp->mnStart]._nSID;
1045     return nSID ? nSID : nWhich;
1046 }
1047
1048 // -----------------------------------------------------------------------
1049
1050 sal_uInt16 SfxItemPool::GetTrueWhich( sal_uInt16 nSlotId, sal_Bool bDeep ) const
1051 {
1052     if ( !IsSlot(nSlotId) )
1053         return 0;
1054
1055     sal_uInt16 nCount = pImp->mnEnd - pImp->mnStart + 1;
1056     for ( sal_uInt16 nOfs = 0; nOfs < nCount; ++nOfs )
1057         if ( pItemInfos[nOfs]._nSID == nSlotId )
1058             return nOfs + pImp->mnStart;
1059     if ( pImp->mpSecondary && bDeep )
1060         return pImp->mpSecondary->GetTrueWhich(nSlotId);
1061     return 0;
1062 }
1063
1064 // -----------------------------------------------------------------------
1065
1066 sal_uInt16 SfxItemPool::GetTrueSlotId( sal_uInt16 nWhich, sal_Bool bDeep ) const
1067 {
1068     if ( !IsWhich(nWhich) )
1069         return 0;
1070
1071     if ( !IsInRange( nWhich ) )
1072     {
1073         if ( pImp->mpSecondary && bDeep )
1074             return pImp->mpSecondary->GetTrueSlotId(nWhich);
1075         SFX_ASSERT( 0, nWhich, "unknown Which-Id - cannot get slot-id" );
1076         return 0;
1077     }
1078     return pItemInfos[nWhich - pImp->mnStart]._nSID;
1079 }
1080
1081 void SfxItemPool::SetFileFormatVersion( sal_uInt16 nFileFormatVersion )
1082
1083 /*  [Description]
1084
1085     You must call this function to set the file format version after
1086     concatenating your secondary-pools but before you store any
1087     pool, itemset or item. Only set the version at the master pool,
1088     never at any secondary pool.
1089 */
1090
1091 {
1092     DBG_ASSERT( this == pImp->mpMaster,
1093                 "SfxItemPool::SetFileFormatVersion() but not a master pool" );
1094     for ( SfxItemPool *pPool = this; pPool; pPool = pPool->pImp->mpSecondary )
1095         pPool->pImp->mnFileFormatVersion = nFileFormatVersion;
1096 }
1097
1098 const SfxItemPool* SfxItemPool::pStoringPool_ = 0;
1099
1100 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */