xref: /aoo41x/main/svl/source/items/itemset.cxx (revision 43f0f119)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svl.hxx"
26 
27 #include <string.h>
28 #include <cstdarg>
29 
30 #define _SVSTDARR_USHORTS
31 #define _SVSTDARR_ULONGS
32 
33 #include <svl/svstdarr.hxx>
34 #include <svl/itemset.hxx>
35 #include <svl/itempool.hxx>
36 #include <svl/itemiter.hxx>
37 #include <svl/whiter.hxx>
38 #include <svl/nranges.hxx>
39 #include "whassert.hxx"
40 
41 #include <tools/stream.hxx>
42 #include <tools/solar.h>
43 
44 // STATIC DATA -----------------------------------------------------------
45 
46 static const sal_uInt16 nInitCount = 10; // einzelne USHORTs => 5 Paare ohne '0'
47 #ifdef DBG_UTIL
48 static sal_uLong nRangesCopyCount = 0;	 // wie oft wurden Ranges kopiert
49 #endif
50 
DBG_NAME(SfxItemSet) const51 DBG_NAME(SfxItemSet)
52 
53 //========================================================================
54 
55 #define NUMTYPE 		sal_uInt16
56 #define SvNums			SvUShorts
57 #define SfxNumRanges    SfxUShortRanges
58 #include "nranges.cxx"
59 #undef NUMTYPE
60 #undef SvNums
61 #undef SfxNumRanges
62 
63 #define NUMTYPE 		sal_uLong
64 #define SvNums			SvULongs
65 #define SfxNumRanges    SfxULongRanges
66 #include "nranges.cxx"
67 #undef NUMTYPE
68 #undef SvNums
69 #undef SfxNumRanges
70 
71 //========================================================================
72 
73 #ifdef DBG_UTIL
74 
75 
76 const sal_Char *DbgCheckItemSet( const void* pVoid )
77 {
78 	const SfxItemSet *pSet = (const SfxItemSet*) pVoid;
79 	SfxWhichIter aIter( *pSet );
80 	sal_uInt16 nCount = 0, n = 0;
81 	for ( sal_uInt16 nWh = aIter.FirstWhich(); nWh; nWh = aIter.NextWhich(), ++n )
82 	{
83 		const SfxPoolItem *pItem = pSet->_aItems[n];
84 		if ( pItem )
85 		{
86 			++nCount;
87 			DBG_ASSERT( IsInvalidItem(pItem) ||
88 						pItem->Which() == 0 || pItem->Which() == nWh,
89 						"SfxItemSet: invalid which-id" );
90 			DBG_ASSERT( IsInvalidItem(pItem) || !pItem->Which() ||
91 					!SfxItemPool::IsWhich(pItem->Which()) ||
92 					pSet->GetPool()->IsItemFlag(nWh, SFX_ITEM_NOT_POOLABLE) ||
93 					SFX_ITEMS_NULL != pSet->GetPool()->GetSurrogate(pItem),
94 					"SfxItemSet: item in set which is not in pool" );
95 		}
96 
97 	}
98 	DBG_ASSERT( pSet->_nCount == nCount, "wrong SfxItemSet::nCount detected" );
99 
100 	return 0;
101 }
102 
103 #endif
104 // -----------------------------------------------------------------------
105 
SfxItemSet(SfxItemPool & rPool,sal_Bool bTotalRanges)106 SfxItemSet::SfxItemSet
107 (
108 	SfxItemPool&	rPool,  		/* der Pool, in dem die SfxPoolItems,
109 									   welche in dieses SfxItemSet gelangen,
110 									   aufgenommen werden sollen */
111 	sal_Bool
112 #ifdef DBG_UTIL
113 #ifdef SFX_ITEMSET_NO_DEFAULT_CTOR
114 
115                     bTotalRanges	/* komplette Pool-Ranges uebernehmen,
116                                        muss auf sal_True gesetzt werden */
117 #endif
118 #endif
119 )
120 /*	[Beschreibung]
121 
122     Konstruktor fuer ein SfxItemSet mit genau den Which-Bereichen, welche
123 	dem angegebenen <SfxItemPool> bekannt sind.
124 
125 
126 	[Anmerkung]
127 
128 	F"ur Sfx-Programmierer ein derart konstruiertes SfxItemSet kann
129 	keinerlei Items mit Slot-Ids als Which-Werte aufnehmen!
130 */
131 
132 :	_pPool( &rPool ),
133 	_pParent( 0 ),
134 	_nCount( 0 ),
135 	_aHashKey( 0 ) //i120575
136 {
137 	DBG_CTOR(SfxItemSet, DbgCheckItemSet);
138 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
139 	DBG( _pChildCountCtor; *_pChildCount(this) = 0 );
140 //	DBG_ASSERT( bTotalRanges || abs( &bTotalRanges - this ) < 1000,
141 //				"please use suitable ranges" );
142 #ifdef DBG_UTIL
143 #ifdef SFX_ITEMSET_NO_DEFAULT_CTOR
144 	if ( !bTotalRanges )
145 		*(int*)0 = 0; // GPF
146 #endif
147 #endif
148 
149 	_pWhichRanges = (sal_uInt16*) _pPool->GetFrozenIdRanges();
150 	DBG_ASSERT( _pWhichRanges, "don't create ItemSets with full range before FreezeIdRanges()" );
151 	if ( !_pWhichRanges )
152 		_pPool->FillItemIdRanges_Impl( _pWhichRanges );
153 
154 	const sal_uInt16 nSize = TotalCount();
155 	_aItems = new const SfxPoolItem* [ nSize ];
156 	memset( (void*) _aItems, 0, nSize * sizeof( SfxPoolItem* ) );
157 }
158 
159 // -----------------------------------------------------------------------
160 
SfxItemSet(SfxItemPool & rPool,sal_uInt16 nWhich1,sal_uInt16 nWhich2)161 SfxItemSet::SfxItemSet( SfxItemPool& rPool, sal_uInt16 nWhich1, sal_uInt16 nWhich2 ):
162 	_pPool( &rPool ),
163 	_pParent( 0 ),
164 	_nCount( 0 ),
165 	_aHashKey( 0 ) //i120575
166 {
167 	DBG_CTOR(SfxItemSet, DbgCheckItemSet);
168 	DBG_ASSERT( nWhich1 <= nWhich2, "Ungueltiger Bereich" );
169 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
170 	DBG( _pChildCountCtor; *_pChildCount(this) = 0 );
171 
172 	InitRanges_Impl(nWhich1, nWhich2);
173 }
174 
175 // -----------------------------------------------------------------------
176 
InitRanges_Impl(sal_uInt16 nWh1,sal_uInt16 nWh2)177 void SfxItemSet::InitRanges_Impl(sal_uInt16 nWh1, sal_uInt16 nWh2)
178 {
179 	DBG_CHKTHIS(SfxItemSet, 0);
180 	_pWhichRanges = new sal_uInt16[ 3 ];
181 	*(_pWhichRanges+0) = nWh1;
182 	*(_pWhichRanges+1) = nWh2;
183 	*(_pWhichRanges+2) = 0;
184 	const sal_uInt16 nRg = nWh2 - nWh1 + 1;
185 	_aItems = new const SfxPoolItem* [ nRg ];
186 	memset( (void*) _aItems, 0, nRg * sizeof( SfxPoolItem* ) );
187 }
188 
189 // -----------------------------------------------------------------------
190 
InitRanges_Impl(va_list pArgs,sal_uInt16 nWh1,sal_uInt16 nWh2,sal_uInt16 nNull)191 void SfxItemSet::InitRanges_Impl(va_list pArgs, sal_uInt16 nWh1, sal_uInt16 nWh2, sal_uInt16 nNull)
192 {
193 	DBG_CHKTHIS(SfxItemSet, 0);
194 
195 	sal_uInt16 nSize = InitializeRanges_Impl( _pWhichRanges, pArgs, nWh1, nWh2, nNull );
196 	_aItems = new const SfxPoolItem* [ nSize ];
197 	memset( (void*) _aItems, 0, sizeof( SfxPoolItem* ) * nSize );
198 }
199 
200 // -----------------------------------------------------------------------
201 
SfxItemSet(SfxItemPool & rPool,USHORT_ARG nWh1,USHORT_ARG nWh2,USHORT_ARG nNull,...)202 SfxItemSet::SfxItemSet( SfxItemPool& rPool,
203 						USHORT_ARG nWh1, USHORT_ARG nWh2, USHORT_ARG nNull, ... ):
204 	_pPool( &rPool ),
205 	_pParent( 0 ),
206 	_pWhichRanges( 0 ),
207 	_nCount( 0 ),
208 	_aHashKey( 0 ) //i120575
209 {
210 	DBG_CTOR(SfxItemSet, DbgCheckItemSet);
211 	DBG_ASSERT( nWh1 <= nWh2, "Ungueltiger Bereich" );
212 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
213 	DBG( _pChildCountCtor; *_pChildCount(this) = 0 );
214 
215 	if(!nNull)
216 		InitRanges_Impl(
217             sal::static_int_cast< sal_uInt16 >(nWh1),
218             sal::static_int_cast< sal_uInt16 >(nWh2));
219 	else {
220 		va_list pArgs;
221 		va_start( pArgs, nNull );
222 		InitRanges_Impl(
223             pArgs, sal::static_int_cast< sal_uInt16 >(nWh1),
224             sal::static_int_cast< sal_uInt16 >(nWh2),
225             sal::static_int_cast< sal_uInt16 >(nNull));
226 	}
227 }
228 
229 // -----------------------------------------------------------------------
230 
InitRanges_Impl(const sal_uInt16 * pWhichPairTable)231 void SfxItemSet::InitRanges_Impl(const sal_uInt16 *pWhichPairTable)
232 {
233 	DBG_CHKTHIS(SfxItemSet, 0);
234 	DBG_TRACE1("SfxItemSet: Ranges-CopyCount==%ul", ++nRangesCopyCount);
235 
236 	sal_uInt16 nCnt = 0;
237 	const sal_uInt16* pPtr = pWhichPairTable;
238 	while( *pPtr )
239 	{
240 		nCnt += ( *(pPtr+1) - *pPtr ) + 1;
241 		pPtr += 2;
242 	}
243 
244 	_aItems = new const SfxPoolItem* [ nCnt ];
245 	memset( (void*) _aItems, 0, sizeof( SfxPoolItem* ) * nCnt );
246 
247 	std::ptrdiff_t cnt = pPtr - pWhichPairTable +1;
248 	_pWhichRanges = new sal_uInt16[ cnt ];
249 	memcpy( _pWhichRanges, pWhichPairTable, sizeof( sal_uInt16 ) * cnt );
250 }
251 
252 
253 // -----------------------------------------------------------------------
254 
SfxItemSet(SfxItemPool & rPool,const sal_uInt16 * pWhichPairTable)255 SfxItemSet::SfxItemSet( SfxItemPool& rPool, const sal_uInt16* pWhichPairTable ):
256 	_pPool( &rPool ),
257 	_pParent( 0 ),
258 	_pWhichRanges(0),
259 	_nCount( 0 ),
260 	_aHashKey( 0 ) //i120575
261 {
262 	DBG_CTOR(SfxItemSet, 0);
263 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
264 	DBG( _pChildCountCtor; *_pChildCount(this) = 0 );
265 
266 	// pWhichPairTable == 0 ist f"ur das SfxAllEnumItemSet
267 	if ( pWhichPairTable )
268 		InitRanges_Impl(pWhichPairTable);
269 }
270 
271 // -----------------------------------------------------------------------
272 
SfxItemSet(const SfxItemSet & rASet)273 SfxItemSet::SfxItemSet( const SfxItemSet& rASet ):
274 	_pPool( rASet._pPool ),
275 	_pParent( rASet._pParent ),
276 	_nCount( rASet._nCount ),
277 	_aHashKey( 0 ) //i120575
278 {
279 	DBG_CTOR(SfxItemSet, DbgCheckItemSet);
280 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
281 	DBG( _pChildCountCtor; *_pChildCount(this) = 0 );
282 	DBG( ++*_pChildCount(_pParent) );
283 
284 	// errechne die Anzahl von Attributen
285 	sal_uInt16 nCnt = 0;
286 	sal_uInt16* pPtr = rASet._pWhichRanges;
287 	while( *pPtr )
288 	{
289 		nCnt += ( *(pPtr+1) - *pPtr ) + 1;
290 		pPtr += 2;
291 	}
292 
293 	_aItems = new const SfxPoolItem* [ nCnt ];
294 
295 	// Attribute kopieren
296 	SfxItemArray ppDst = _aItems, ppSrc = rASet._aItems;
297 	for( sal_uInt16 n = nCnt; n; --n, ++ppDst, ++ppSrc )
298 		if ( 0 == *ppSrc || 				// aktueller Default?
299 			 IsInvalidItem(*ppSrc) ||		// Dont Care?
300 			 IsStaticDefaultItem(*ppSrc) )	// nicht zu poolende Defaults
301 			// einfach Pointer kopieren
302 			*ppDst = *ppSrc;
303 		else if ( _pPool->IsItemFlag( **ppSrc, SFX_ITEM_POOLABLE ) )
304 		{
305 			// einfach Pointer kopieren und Ref-Count erh"ohen
306 			*ppDst = *ppSrc;
307 			( (SfxPoolItem*) (*ppDst) )->AddRef();
308 		}
309 		else if ( !(*ppSrc)->Which() )
310 			*ppDst = (*ppSrc)->Clone();
311 		else
312 			// !IsPoolable() => via Pool zuweisen
313 			*ppDst = &_pPool->Put( **ppSrc );
314 
315 	// dann noch die Which Ranges kopieren
316 	DBG_TRACE1("SfxItemSet: Ranges-CopyCount==%ul", ++nRangesCopyCount);
317 	std::ptrdiff_t cnt = pPtr - rASet._pWhichRanges+1;
318 	_pWhichRanges = new sal_uInt16[ cnt ];
319 	memcpy( _pWhichRanges, rASet._pWhichRanges, sizeof( sal_uInt16 ) * cnt);
320 }
321 
322 // -----------------------------------------------------------------------
323 
~SfxItemSet()324 SfxItemSet::~SfxItemSet()
325 {
326 	DBG_DTOR(SfxItemSet, DbgCheckItemSet);
327 #ifdef DBG_UTIL
328 	DBG( DBG_ASSERT( 0 == *_pChildCount(this), "SfxItemSet: deleting parent-itemset" ) )
329 #endif
330 
331 	sal_uInt16 nCount = TotalCount();
332 	if( Count() )
333 	{
334 		SfxItemArray ppFnd = _aItems;
335 		for( sal_uInt16 nCnt = nCount; nCnt; --nCnt, ++ppFnd )
336 			if( *ppFnd && !IsInvalidItem(*ppFnd) )
337 			{
338 				if( !(*ppFnd)->Which() )
339 					delete (SfxPoolItem*) *ppFnd;
340 				else {
341 					// noch mehrer Referenzen vorhanden, also nur den
342 					// ReferenzCounter manipulieren
343 					if ( 1 < (*ppFnd)->GetRefCount() && !IsDefaultItem(*ppFnd) )
344 						(*ppFnd)->ReleaseRef();
345 					else
346 						if ( !IsDefaultItem(*ppFnd) )
347 							// aus dem Pool loeschen
348 							_pPool->Remove( **ppFnd );
349 				}
350 			}
351 	}
352 
353 	// FIXME: could be delete[] (SfxPoolItem **)_aItems;
354 	delete[] _aItems;
355 	if ( _pWhichRanges != _pPool->GetFrozenIdRanges() )
356 		delete[] _pWhichRanges;
357 	_pWhichRanges = 0; // for invariant-testing
358 
359 	DBG( --*_pChildCount(_pParent) );
360 	DBG( delete _pChildCount(this); _pChildCountDtor );
361 }
362 
363 // -----------------------------------------------------------------------
364 
ClearItem(sal_uInt16 nWhich)365 sal_uInt16 SfxItemSet::ClearItem( sal_uInt16 nWhich )
366 
367 // einzelnes Item oder alle Items (nWhich==0) l"oschen
368 
369 {
370 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
371 	if( !Count() )
372 		return 0;
373 
374 	sal_uInt16 nDel = 0;
375 	SfxItemArray ppFnd = _aItems;
376 
377 	if( nWhich )
378 	{
379 		const sal_uInt16* pPtr = _pWhichRanges;
380 		while( *pPtr )
381 		{
382 			// in diesem Bereich?
383 			if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
384 			{
385 				// "uberhaupt gesetzt?
386 				ppFnd += nWhich - *pPtr;
387 				if( *ppFnd )
388 				{
389 					// wegen der Assertions ins Sub-Calls mu\s das hier sein
390 					--_nCount;
391 					const SfxPoolItem *pItemToClear = *ppFnd;
392 					*ppFnd = 0;
393 
394 					if ( !IsInvalidItem(pItemToClear) )
395 					{
396 						if ( nWhich <= SFX_WHICH_MAX )
397 						{
398 							const SfxPoolItem& rNew = _pParent
399 									? _pParent->Get( nWhich, sal_True )
400 									: _pPool->GetDefaultItem( nWhich );
401 
402 							Changed( *pItemToClear, rNew );
403 						}
404 						if ( pItemToClear->Which() )
405 							_pPool->Remove( *pItemToClear );
406 					}
407 					++nDel;
408 				}
409 
410 				// gefunden => raus
411 				break;
412 			}
413 			ppFnd += *(pPtr+1) - *pPtr + 1;
414 			pPtr += 2;
415 		}
416 	}
417 	else
418 	{
419 		nDel = _nCount;
420 
421 		sal_uInt16* pPtr = _pWhichRanges;
422 		while( *pPtr )
423 		{
424 			for( nWhich = *pPtr; nWhich <= *(pPtr+1); ++nWhich, ++ppFnd )
425 				if( *ppFnd )
426 				{
427 					// wegen der Assertions ins Sub-Calls mu\s das hier sein
428 					--_nCount;
429 					const SfxPoolItem *pItemToClear = *ppFnd;
430 					*ppFnd = 0;
431 
432 					if ( !IsInvalidItem(pItemToClear) )
433 					{
434 						if ( nWhich <= SFX_WHICH_MAX )
435 						{
436 							const SfxPoolItem& rNew = _pParent
437 									? _pParent->Get( nWhich, sal_True )
438 									: _pPool->GetDefaultItem( nWhich );
439 
440 							Changed( *pItemToClear, rNew );
441 						}
442 
443 						// #i32448#
444 						// Take care of disabled items, too.
445 						if(!pItemToClear->nWhich)
446 						{
447 							// item is disabled, delete it
448 							delete pItemToClear;
449 						}
450 						else
451 						{
452 							// remove item from pool
453 							_pPool->Remove( *pItemToClear );
454 						}
455 					}
456 				}
457 			pPtr += 2;
458 		}
459 	}
460 	InvalidateHashKey();	//i120575
461 	return nDel;
462 }
463 
464 // -----------------------------------------------------------------------
465 
ClearInvalidItems(sal_Bool bHardDefault)466 void SfxItemSet::ClearInvalidItems( sal_Bool bHardDefault )
467 {
468 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
469 	sal_uInt16* pPtr = _pWhichRanges;
470 	SfxItemArray ppFnd = _aItems;
471 	if ( bHardDefault )
472 		while( *pPtr )
473 		{
474 			for ( sal_uInt16 nWhich = *pPtr; nWhich <= *(pPtr+1); ++nWhich, ++ppFnd )
475 				if ( IsInvalidItem(*ppFnd) )
476 					 *ppFnd = &_pPool->Put( _pPool->GetDefaultItem(nWhich) );
477 			pPtr += 2;
478 		}
479 	else
480 		while( *pPtr )
481 		{
482 			for( sal_uInt16 nWhich = *pPtr; nWhich <= *(pPtr+1); ++nWhich, ++ppFnd )
483 				if( IsInvalidItem(*ppFnd) )
484 				{
485 					*ppFnd = 0;
486 					--_nCount;
487 				}
488 			pPtr += 2;
489 		}
490 	InvalidateHashKey();	//i120575
491 }
492 
493 //------------------------------------------------------------------------
494 
495 
InvalidateAllItems()496 void SfxItemSet::InvalidateAllItems()
497 {
498 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
499 	DBG_ASSERT( !_nCount, "Es sind noch Items gesetzt" );
500 
501 	memset( (void*)_aItems, -1, ( _nCount = TotalCount() ) * sizeof( SfxPoolItem*) );
502 	InvalidateHashKey();	//i120575
503 }
504 
505 // -----------------------------------------------------------------------
506 
GetItemState(sal_uInt16 nWhich,sal_Bool bSrchInParent,const SfxPoolItem ** ppItem) const507 SfxItemState SfxItemSet::GetItemState( sal_uInt16 nWhich,
508 										sal_Bool bSrchInParent,
509 										const SfxPoolItem **ppItem ) const
510 {
511 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
512 	// suche den Bereich in dem das Which steht:
513 	const SfxItemSet* pAktSet = this;
514 	SfxItemState eRet = SFX_ITEM_UNKNOWN;
515 	do
516 	{
517 		SfxItemArray ppFnd = pAktSet->_aItems;
518 		const sal_uInt16* pPtr = pAktSet->_pWhichRanges;
519 		if (pPtr)
520 		{
521 			while ( *pPtr )
522 			{
523 				if ( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
524 				{
525 					// in diesem Bereich
526 					ppFnd += nWhich - *pPtr;
527 					if ( !*ppFnd )
528 					{
529 						eRet = SFX_ITEM_DEFAULT;
530 						if( !bSrchInParent )
531 							return eRet;  // nicht vorhanden
532 						break; // JP: in den Parents weitersuchen !!!
533 					}
534 
535 					if ( (SfxPoolItem*) -1 == *ppFnd )
536 						// Unterschiedlich vorhanden
537 						return SFX_ITEM_DONTCARE;
538 
539 					if ( (*ppFnd)->Type() == TYPE(SfxVoidItem) )
540 						return SFX_ITEM_DISABLED;
541 
542 					if (ppItem)
543 					{
544                         #ifdef DBG_UTIL
545 						const SfxPoolItem *pItem = *ppFnd;
546 						DBG_ASSERT( !pItem->ISA(SfxSetItem) ||
547 								0 != &((const SfxSetItem*)pItem)->GetItemSet(),
548 								"SetItem without ItemSet" );
549                         #endif
550 						*ppItem = *ppFnd;
551 					}
552 					return SFX_ITEM_SET;
553 				}
554 				ppFnd += *(pPtr+1) - *pPtr + 1;
555 				pPtr += 2;
556 			}
557 		}
558 	} while( bSrchInParent && 0 != ( pAktSet = pAktSet->_pParent ));
559 	return eRet;
560 }
561 
562 // -----------------------------------------------------------------------
563 
Put(const SfxPoolItem & rItem,sal_uInt16 nWhich)564 const SfxPoolItem* SfxItemSet::Put( const SfxPoolItem& rItem, sal_uInt16 nWhich )
565 {
566 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
567 	DBG_ASSERT( !rItem.ISA(SfxSetItem) ||
568 			0 != &((const SfxSetItem&)rItem).GetItemSet(),
569 			"SetItem without ItemSet" );
570 	if ( !nWhich )
571 		return 0; //! nur wegen Outliner-Bug
572 	SfxItemArray ppFnd = _aItems;
573 	const sal_uInt16* pPtr = _pWhichRanges;
574 	while( *pPtr )
575 	{
576 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
577 		{
578 			// in diesem Bereich
579 			ppFnd += nWhich - *pPtr;
580 			if( *ppFnd )		// schon einer vorhanden
581 			{
582 				// selbes Item bereits vorhanden?
583 				if ( *ppFnd == &rItem )
584 					return 0;
585 
586 				// wird dontcare oder disabled mit was echtem ueberschrieben?
587 				if ( rItem.Which() && ( IsInvalidItem(*ppFnd) || !(*ppFnd)->Which() ) )
588 				{
589 					*ppFnd = &_pPool->Put( rItem, nWhich );
590 					InvalidateHashKey();	//i120575
591 					return *ppFnd;
592 				}
593 
594 				// wird disabled?
595 				if( !rItem.Which() )
596 				{
597 					*ppFnd = rItem.Clone(_pPool);
598 					InvalidateHashKey();	//i120575
599 					return 0;
600 				}
601 				else
602 				{
603 					// selber Wert bereits vorhanden?
604 					if ( rItem == **ppFnd )
605 						return 0;
606 
607 					// den neuen eintragen, den alten austragen
608 					const SfxPoolItem& rNew = _pPool->Put( rItem, nWhich );
609 					const SfxPoolItem* pOld = *ppFnd;
610 					*ppFnd = &rNew;
611 					if(nWhich <= SFX_WHICH_MAX)
612 						Changed( *pOld, rNew );
613 					_pPool->Remove( *pOld );
614 				}
615 			}
616 			else
617 			{
618 				++_nCount;
619 				if( !rItem.Which() )
620 					*ppFnd = rItem.Clone(_pPool);
621 				else {
622 					const SfxPoolItem& rNew = _pPool->Put( rItem, nWhich );
623 					*ppFnd = &rNew;
624 					if (nWhich <= SFX_WHICH_MAX )
625 					{
626 						const SfxPoolItem& rOld = _pParent
627 							? _pParent->Get( nWhich, sal_True )
628 							: _pPool->GetDefaultItem( nWhich );
629 						Changed( rOld, rNew );
630 					}
631 				}
632 			}
633 			SFX_ASSERT( !_pPool->IsItemFlag(nWhich, SFX_ITEM_POOLABLE) ||
634 						rItem.ISA(SfxSetItem) || **ppFnd == rItem,
635 						nWhich, "putted Item unequal" );
636 
637 			InvalidateHashKey();	//i120575
638 			return *ppFnd;
639 		}
640 		ppFnd += *(pPtr+1) - *pPtr + 1;
641 		pPtr += 2;
642 	}
643 	InvalidateHashKey();	//i120575
644 	return 0;
645 }
646 
647 // -----------------------------------------------------------------------
648 
Put(const SfxItemSet & rSet,sal_Bool bInvalidAsDefault)649 int SfxItemSet::Put( const SfxItemSet& rSet, sal_Bool bInvalidAsDefault )
650 {
651 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
652 	sal_Bool bRet = sal_False;
653 	if( rSet.Count() )
654 	{
655 		SfxItemArray ppFnd = rSet._aItems;
656 		const sal_uInt16* pPtr = rSet._pWhichRanges;
657 		while ( *pPtr )
658 		{
659 			for ( sal_uInt16 nWhich = *pPtr; nWhich <= *(pPtr+1); ++nWhich, ++ppFnd )
660 				if( *ppFnd )
661 				{
662 					if ( IsInvalidItem( *ppFnd ) )
663 					{
664 						if ( bInvalidAsDefault )
665 							bRet |= 0 != ClearItem( nWhich );
666 							// gab GPF bei non.WIDs:
667 							// bRet |= 0 != Put( rSet.GetPool()->GetDefaultItem(nWhich), nWhich );
668 						else
669 							InvalidateItem( nWhich );
670 					}
671 					else
672 						bRet |= 0 != Put( **ppFnd, nWhich );
673 				}
674 			pPtr += 2;
675 		}
676 	}
677 	return bRet;
678 }
679 
680 // -----------------------------------------------------------------------
681 
PutExtended(const SfxItemSet & rSet,SfxItemState eDontCareAs,SfxItemState eDefaultAs)682 void SfxItemSet::PutExtended
683 (
684 	const SfxItemSet&	rSet,			// Quelle der zu puttenden Items
685 	SfxItemState		eDontCareAs,	// was mit DontCare-Items passiert
686 	SfxItemState		eDefaultAs		// was mit Default-Items passiert
687 )
688 
689 /*	[Beschreibung]
690 
691 	Diese Methode "ubernimmt die Items aus 'rSet' in '*this'. Die
692 	Which-Bereiche in '*this', die in 'rSet' nicht vorkommen bleiben unver-
693 	"andert. Der Which-Bereich von '*this' bleibt auch unver"andert.
694 
695 	In 'rSet' gesetzte Items werden auch in '*this*' gesetzt. Default-
696 	(0 Pointer) und Invalid- (-1 Pointer) Items werden je nach Parameter
697 	('eDontCareAs' und 'eDefaultAs' behandelt:
698 
699 	SFX_ITEM_SET:		hart auf Default des Pools gesetzt
700 	SFX_ITEM_DEFAULT:	gel"oscht (0 Pointer)
701 	SFX_ITEM_DONTCARE:	invalidiert (-1 Pointer)
702 
703 	Alle anderen Werte f"ur 'eDontCareAs' und 'eDefaultAs' sind ung"ultig.
704 */
705 
706 {
707 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
708 
709 	// don't "optimize" with "if( rSet.Count()" because of dont-care + defaults
710 	SfxItemArray ppFnd = rSet._aItems;
711 	const sal_uInt16* pPtr = rSet._pWhichRanges;
712 	while ( *pPtr )
713 	{
714 		for ( sal_uInt16 nWhich = *pPtr; nWhich <= *(pPtr+1); ++nWhich, ++ppFnd )
715 			if( *ppFnd )
716 			{
717 				if ( IsInvalidItem( *ppFnd ) )
718 				{
719 					// Item ist DontCare:
720 					switch ( eDontCareAs )
721 					{
722 						case SFX_ITEM_SET:
723 							Put( rSet.GetPool()->GetDefaultItem(nWhich), nWhich );
724 							break;
725 
726 						case SFX_ITEM_DEFAULT:
727 							ClearItem( nWhich );
728 							break;
729 
730 						case SFX_ITEM_DONTCARE:
731 							InvalidateItem( nWhich );
732 							break;
733 
734 						default:
735 							DBG_ERROR( "invalid Argument for eDontCareAs" );
736 					}
737 				}
738 				else
739 					// Item ist gesetzt:
740 					Put( **ppFnd, nWhich );
741 			}
742 			else
743 			{
744 				// Item ist Default:
745 				switch ( eDefaultAs )
746 				{
747 					case SFX_ITEM_SET:
748 						Put( rSet.GetPool()->GetDefaultItem(nWhich), nWhich );
749 						break;
750 
751 					case SFX_ITEM_DEFAULT:
752 						ClearItem( nWhich );
753 						break;
754 
755 					case SFX_ITEM_DONTCARE:
756 						InvalidateItem( nWhich );
757 						break;
758 
759 					default:
760 						DBG_ERROR( "invalid Argument for eDefaultAs" );
761 				}
762 			}
763 		pPtr += 2;
764 	}
765 }
766 
767 // -----------------------------------------------------------------------
768 
MergeRange(sal_uInt16 nFrom,sal_uInt16 nTo)769 void SfxItemSet::MergeRange( sal_uInt16 nFrom, sal_uInt16 nTo )
770 /**	<H3>Description</H3>
771 
772 	Expands the ranges of settable items by 'nFrom' to 'nTo'. Keeps state of
773 	items which are new ranges too.
774 */
775 
776 {
777 	// special case: exactly one sal_uInt16 which is already included?
778 	if ( nFrom == nTo && SFX_ITEM_AVAILABLE <= GetItemState(nFrom, sal_False) )
779 		return;
780 
781 	// merge new range
782 	SfxUShortRanges aRanges( _pWhichRanges );
783 	aRanges += SfxUShortRanges( nFrom, nTo );
784 	SetRanges( aRanges );
785 }
786 
787 // -----------------------------------------------------------------------
788 
SetRanges(const sal_uInt16 * pNewRanges)789 void SfxItemSet::SetRanges( const sal_uInt16 *pNewRanges )
790 
791 /**	<H3>Description</H3>
792 
793 	Modifies the ranges of settable items. Keeps state of items which
794 	are new ranges too.
795 */
796 
797 {
798 	// identische Ranges?
799 	if ( _pWhichRanges == pNewRanges )
800 		return;
801 	const sal_uInt16* pOld = _pWhichRanges;
802 	const sal_uInt16* pNew = pNewRanges;
803 	while ( *pOld == *pNew )
804 	{
805 		if ( !*pOld && !*pNew )
806 			return;
807 		++pOld, ++pNew;
808 	}
809 
810 	// create new item-array (by iterating through all new ranges)
811 	sal_uLong		 nSize = Capacity_Impl(pNewRanges);
812 	SfxItemArray aNewItems = new const SfxPoolItem* [ nSize ];
813 	sal_uInt16		 n = 0, nNewCount = 0;
814 	if ( _nCount == 0 )
815 		memset( aNewItems, 0, nSize * sizeof( SfxPoolItem* ) );
816 	else
817 	{
818 		for ( const sal_uInt16 *pRange = pNewRanges; *pRange; pRange += 2 )
819 		{
820 			// iterate through all ids in the range
821 			for ( sal_uInt16 nWID = *pRange; nWID <= pRange[1]; ++nWID, ++n )
822 			{
823 				// direct move of pointer (not via pool)
824 				SfxItemState eState = GetItemState( nWID, sal_False, aNewItems+n );
825 				if ( SFX_ITEM_SET == eState )
826 				{
827 					// increment new item count and possibly increment ref count
828 					++nNewCount;
829 					aNewItems[n]->AddRef();
830 				}
831 				else if ( SFX_ITEM_DISABLED == eState )
832 				{
833 					// put "disabled" item
834 					++nNewCount;
835 					aNewItems[n] = new SfxVoidItem(0);
836 				}
837 				else if ( SFX_ITEM_DONTCARE == eState )
838 				{
839 					++nNewCount;
840 					aNewItems[n] = (SfxPoolItem*)-1;
841 				}
842 				else
843 				{
844 					// default
845 					aNewItems[n] = 0;
846 				}
847 			}
848 		}
849 		// free old items
850 		sal_uInt16 nOldTotalCount = TotalCount();
851 		for ( sal_uInt16 nItem = 0; nItem < nOldTotalCount; ++nItem )
852 		{
853 			const SfxPoolItem *pItem = _aItems[nItem];
854 			if ( pItem && !IsInvalidItem(pItem) && pItem->Which() )
855 				_pPool->Remove(*pItem);
856 		}
857 	}
858 
859 	// replace old items-array and ranges
860 	delete[] _aItems;
861 	_aItems = aNewItems;
862 	_nCount = nNewCount;
863 
864 	if( pNewRanges == GetPool()->GetFrozenIdRanges() )
865 	{
866 		delete[] _pWhichRanges;
867 		_pWhichRanges = ( sal_uInt16* ) pNewRanges;
868 	}
869 	else
870 	{
871 		sal_uInt16 nCount = Count_Impl(pNewRanges) + 1;
872 		if ( _pWhichRanges != _pPool->GetFrozenIdRanges() )
873 			delete[] _pWhichRanges;
874 		_pWhichRanges = new sal_uInt16[ nCount ];
875 		memcpy( _pWhichRanges, pNewRanges, sizeof( sal_uInt16 ) * nCount );
876 	}
877 	InvalidateHashKey();	//i120575
878 }
879 
880 // -----------------------------------------------------------------------
881 
Set(const SfxItemSet & rSet,sal_Bool bDeep)882 int SfxItemSet::Set
883 (
884 	const SfxItemSet&	rSet,	/*	das SfxItemSet, dessen SfxPoolItems
885 									"ubernommen werden sollen */
886 
887 	sal_Bool				bDeep	/*	sal_True (default)
888 									auch die SfxPoolItems aus den ggf. an
889 									rSet vorhandenen Parents werden direkt
890 									in das SfxItemSet "ubernommen
891 
892 									sal_False
893 									die SfxPoolItems aus den Parents von
894 									rSet werden nicht ber"ucksichtigt */
895 )
896 
897 /*	[Beschreibung]
898 
899 	Das SfxItemSet nimmt genau die SfxPoolItems an, die auch in
900 	rSet gesetzt sind und im eigenen <Which-Bereich> liegen. Alle
901 	anderen werden entfernt. Der SfxItemPool wird dabei beibehalten,
902 	so da"s die "ubernommenen SfxPoolItems dabei ggf. vom SfxItemPool
903 	von rSet in den SfxItemPool von *this "ubernommen werden.
904 
905 	SfxPoolItems, f"ur die in rSet IsInvalidItem() == sal_True gilt,
906 	werden als Invalid-Item "ubernommen.
907 
908 
909 	[R"uckgabewert]
910 
911 	int 							sal_True
912 									es wurden SfxPoolItems "ubernommen
913 
914 									sal_False
915 									es wurden keine SfxPoolItems "ubernommen,
916 									da z.B. die Which-Bereiche der SfxItemSets
917 									keine Schnittmenge haben oder in der
918 									Schnittmenge keine SfxPoolItems in rSet
919 									gesetzt sind
920 
921 */
922 
923 {
924 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
925 	int bRet = sal_False;
926 	if ( _nCount )
927 		ClearItem();
928 	if ( bDeep )
929 	{
930 		SfxWhichIter aIter(*this);
931 		sal_uInt16 nWhich = aIter.FirstWhich();
932 		while ( nWhich )
933 		{
934 			const SfxPoolItem* pItem;
935 			if( SFX_ITEM_SET == rSet.GetItemState( nWhich, sal_True, &pItem ) )
936 				bRet |= 0 != Put( *pItem, pItem->Which() );
937 			nWhich = aIter.NextWhich();
938 		}
939 	}
940 	else
941 		bRet = Put(rSet, sal_False);
942 
943 	return bRet;
944 }
945 
946 //------------------------------------------------------------------------
947 
GetItem(sal_uInt16 nId,sal_Bool bSrchInParent,TypeId aItemType) const948 const SfxPoolItem* SfxItemSet::GetItem
949 (
950 	sal_uInt16 				nId,   			// Slot-Id oder Which-Id des Items
951 	sal_Bool 				bSrchInParent,  // sal_True: auch in Parent-ItemSets suchen
952 	TypeId 				aItemType       // != 0 =>  RTTI Pruefung mit Assertion
953 )	const
954 
955 /*	[Beschreibung]
956 
957 	Mit dieser Methode wird der Zugriff auf einzelne Items im
958 	SfxItemSet wesentlich vereinfacht. Insbesondere wird die Typpr"ufung
959 	(per Assertion) durchgef"uhrt, wodurch die Applikations-Sourcen
960 	wesentlich "ubersichtlicher werden. In der PRODUCT-Version wird
961 	eine 0 zur"uckgegeben, wenn das gefundene Item nicht von der
962 	angegebenen Klasse ist. Ist kein Item mit der Id 'nWhich' in dem ItemSet,
963 	so wird 0 zurueckgegeben.
964 */
965 
966 {
967 	// ggf. in Which-Id umrechnen
968 	sal_uInt16 nWhich = GetPool()->GetWhich(nId);
969 
970 	// ist das Item gesetzt oder bei bDeep==sal_True verf"ugbar?
971 	const SfxPoolItem *pItem = 0;
972 	SfxItemState eState = GetItemState( nWhich, bSrchInParent, &pItem );
973 	if ( bSrchInParent && SFX_ITEM_AVAILABLE == eState &&
974 		 nWhich <= SFX_WHICH_MAX )
975 		pItem = &_pPool->GetDefaultItem(nWhich);
976 	if ( pItem )
977 	{
978 		// stimmt der Typ "uberein?
979 		if ( !aItemType || pItem->IsA(aItemType) )
980 			return pItem;
981 
982 		// sonst Fehler melden
983 		DBG_ERROR( "invalid argument type" );
984 	}
985 
986 	// kein Item gefunden oder falschen Typ gefunden
987 	return 0;
988 }
989 
990 
991 //------------------------------------------------------------------------
992 
993 
Get(sal_uInt16 nWhich,sal_Bool bSrchInParent) const994 const SfxPoolItem& SfxItemSet::Get( sal_uInt16 nWhich, sal_Bool bSrchInParent) const
995 {
996 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
997 	// suche den Bereich in dem das Which steht:
998 	const SfxItemSet* pAktSet = this;
999 	do
1000 	{
1001 		if( pAktSet->Count() )
1002 		{
1003 			SfxItemArray ppFnd = pAktSet->_aItems;
1004 			const sal_uInt16* pPtr = pAktSet->_pWhichRanges;
1005 			while( *pPtr )
1006 			{
1007 				if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1008 				{
1009 					// in diesem Bereich
1010 					ppFnd += nWhich - *pPtr;
1011 					if( *ppFnd )
1012 					{
1013 						if( (SfxPoolItem*)-1 == *ppFnd ) {
1014 							//?MI: folgender code ist Doppelt (unten)
1015 							SFX_ASSERT(_pPool, nWhich, "kein Pool, aber Status uneindeutig");
1016 							//!((SfxAllItemSet *)this)->aDefault.SetWhich(nWhich);
1017 							//!return aDefault;
1018 							return _pPool->GetDefaultItem( nWhich );
1019 						}
1020 #ifdef DBG_UTIL
1021 						const SfxPoolItem *pItem = *ppFnd;
1022 						DBG_ASSERT( !pItem->ISA(SfxSetItem) ||
1023 								0 != &((const SfxSetItem*)pItem)->GetItemSet(),
1024 								"SetItem without ItemSet" );
1025 						if ( pItem->ISA(SfxVoidItem) || !pItem->Which() )
1026 							DBG_WARNING( "SFX_WARNING: Getting disabled Item" );
1027 #endif
1028 						return **ppFnd;
1029 					}
1030 					break; 			// dann beim Parent suchen
1031 				}
1032 				ppFnd += *(pPtr+1) - *pPtr + 1;
1033 				pPtr += 2;
1034 			}
1035 		}
1036 // bis zum Ende vom Such-Bereich: was nun ? zum Parent, oder Default ??
1037 //		if( !*pPtr )			// bis zum Ende vom Such-Bereich ?
1038 //		break;
1039 	} while( bSrchInParent && 0 != ( pAktSet = pAktSet->_pParent ));
1040 
1041 	// dann das Default vom Pool holen und returnen
1042 	SFX_ASSERT(_pPool, nWhich, "kein Pool, aber Status uneindeutig");
1043 	const SfxPoolItem *pItem = &_pPool->GetDefaultItem( nWhich );
1044 	DBG_ASSERT( !pItem->ISA(SfxSetItem) ||
1045 			0 != &((const SfxSetItem*)pItem)->GetItemSet(),
1046 			"SetItem without ItemSet" );
1047 	return *pItem;
1048 }
1049 
1050 	// Notification-Callback
1051 // -----------------------------------------------------------------------
1052 
Changed(const SfxPoolItem &,const SfxPoolItem &)1053 void SfxItemSet::Changed( const SfxPoolItem&, const SfxPoolItem& )
1054 {
1055 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1056 }
1057 
1058 // -----------------------------------------------------------------------
1059 
TotalCount() const1060 sal_uInt16 SfxItemSet::TotalCount() const
1061 {
1062 	DBG_CHKTHIS(SfxItemSet, 0); // wird im Ctor benutzt bevor vollst. init.
1063 	sal_uInt16 nRet = 0;
1064 	sal_uInt16* pPtr = _pWhichRanges;
1065 	while( *pPtr )
1066 	{
1067 		nRet += ( *(pPtr+1) - *pPtr ) + 1;
1068 		pPtr += 2;
1069 	}
1070 	return nRet;
1071 }
1072 // -----------------------------------------------------------------------
1073 
1074 // behalte nur die Items, die auch in rSet enthalten sein (Wert egal)
1075 
Intersect(const SfxItemSet & rSet)1076 void SfxItemSet::Intersect( const SfxItemSet& rSet )
1077 {
1078 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1079 	DBG_ASSERT(_pPool, "nicht implementiert ohne Pool");
1080 	if( !Count() )		 // gar keine gesetzt ?
1081 		return;
1082 
1083 	// loesche alle Items, die im rSet nicht mehr vorhanden sind
1084 	if( !rSet.Count() )
1085 	{
1086 		ClearItem();		// alles loeschen
1087 		return;
1088 	}
1089 
1090 	// teste mal, ob sich die Which-Bereiche unterscheiden.
1091 	sal_Bool bEqual = sal_True;
1092 	sal_uInt16* pWh1 = _pWhichRanges;
1093 	sal_uInt16* pWh2 = rSet._pWhichRanges;
1094 	sal_uInt16 nSize = 0;
1095 
1096 	for( sal_uInt16 n = 0; *pWh1 && *pWh2; ++pWh1, ++pWh2, ++n )
1097 	{
1098 		if( *pWh1 != *pWh2 )
1099 		{
1100 			bEqual = sal_False;
1101 			break;
1102 		}
1103 		if( n & 1 )
1104 			nSize += ( *(pWh1) - *(pWh1-1) ) + 1;
1105 	}
1106 	bEqual = *pWh1 == *pWh2;		// auch die 0 abpruefen
1107 
1108 	// sind die Bereiche identisch, ist es einfacher zu handhaben !
1109 	if( bEqual )
1110 	{
1111 		SfxItemArray ppFnd1 = _aItems;
1112 		SfxItemArray ppFnd2 = rSet._aItems;
1113 
1114 		for( ; nSize; --nSize, ++ppFnd1, ++ppFnd2 )
1115 			if( *ppFnd1 && !*ppFnd2 )
1116 			{
1117 				// aus dem Pool loeschen
1118 				if( !IsInvalidItem( *ppFnd1 ) )
1119 				{
1120 					sal_uInt16 nWhich = (*ppFnd1)->Which();
1121 					if(nWhich <= SFX_WHICH_MAX)
1122 					{
1123 						const SfxPoolItem& rNew = _pParent
1124 							? _pParent->Get( nWhich, sal_True )
1125 							: _pPool->GetDefaultItem( nWhich );
1126 
1127 						Changed( **ppFnd1, rNew );
1128 					}
1129 					_pPool->Remove( **ppFnd1 );
1130 				}
1131 				*ppFnd1 = 0;
1132 				--_nCount;
1133 			}
1134 	}
1135 	else
1136 	{
1137 		SfxItemIter aIter( *this );
1138 		const SfxPoolItem* pItem = aIter.GetCurItem();
1139 		while( sal_True )
1140 		{
1141 			sal_uInt16 nWhich = IsInvalidItem( pItem )
1142 								? GetWhichByPos( aIter.GetCurPos() )
1143 								: pItem->Which();
1144 			if( 0 == rSet.GetItemState( nWhich, sal_False ) )
1145 				ClearItem( nWhich );		// loeschen
1146 			if( aIter.IsAtEnd() )
1147 				break;
1148 			pItem = aIter.NextItem();
1149 		}
1150 	}
1151 	InvalidateHashKey();	//i120575
1152 }
1153 
1154 // -----------------------------------------------------------------------
1155 
Differentiate(const SfxItemSet & rSet)1156 void SfxItemSet::Differentiate( const SfxItemSet& rSet )
1157 {
1158 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1159 	if( !Count() || !rSet.Count() )  // gar keine gesetzt ?
1160 		return;
1161 
1162 	// teste mal, ob sich die Which-Bereiche unterscheiden.
1163 	sal_Bool bEqual = sal_True;
1164 	sal_uInt16* pWh1 = _pWhichRanges;
1165 	sal_uInt16* pWh2 = rSet._pWhichRanges;
1166 	sal_uInt16 nSize = 0;
1167 
1168 	for( sal_uInt16 n = 0; *pWh1 && *pWh2; ++pWh1, ++pWh2, ++n )
1169 	{
1170 		if( *pWh1 != *pWh2 )
1171 		{
1172 			bEqual = sal_False;
1173 			break;
1174 		}
1175 		if( n & 1 )
1176 			nSize += ( *(pWh1) - *(pWh1-1) ) + 1;
1177 	}
1178 	bEqual = *pWh1 == *pWh2;		// auch die 0 abpruefen
1179 
1180 	// sind die Bereiche identisch, ist es einfacher zu handhaben !
1181 	if( bEqual )
1182 	{
1183 		SfxItemArray ppFnd1 = _aItems;
1184 		SfxItemArray ppFnd2 = rSet._aItems;
1185 
1186 		for( ; nSize; --nSize, ++ppFnd1, ++ppFnd2 )
1187 			if( *ppFnd1 && *ppFnd2 )
1188 			{
1189 				// aus dem Pool loeschen
1190 				if( !IsInvalidItem( *ppFnd1 ) )
1191 				{
1192 					sal_uInt16 nWhich = (*ppFnd1)->Which();
1193 					if(nWhich <= SFX_WHICH_MAX)
1194 					{
1195 						const SfxPoolItem& rNew = _pParent
1196 							? _pParent->Get( nWhich, sal_True )
1197 							: _pPool->GetDefaultItem( nWhich );
1198 
1199 						Changed( **ppFnd1, rNew );
1200 					}
1201 					_pPool->Remove( **ppFnd1 );
1202 				}
1203 				*ppFnd1 = 0;
1204 				--_nCount;
1205 			}
1206 	}
1207 	else
1208 	{
1209 		SfxItemIter aIter( *this );
1210 		const SfxPoolItem* pItem = aIter.GetCurItem();
1211 		while( sal_True )
1212 		{
1213 			sal_uInt16 nWhich = IsInvalidItem( pItem )
1214 								? GetWhichByPos( aIter.GetCurPos() )
1215 								: pItem->Which();
1216 			if( SFX_ITEM_SET == rSet.GetItemState( nWhich, sal_False ) )
1217 				ClearItem( nWhich );		// loeschen
1218 			if( aIter.IsAtEnd() )
1219 				break;
1220 			pItem = aIter.NextItem();
1221 		}
1222 
1223 	}
1224 	InvalidateHashKey();	//i120575
1225 }
1226 
1227 // -----------------------------------------------------------------------
1228 /* Entscheidungstabelle fuer MergeValue[s]
1229 
1230 Grundsaetze:
1231 	1. Ist der Which-Wert im 1.Set "unknown", dann folgt niemals eine Aktion.
1232 	2. Ist der Which-Wert im 2.Set "unknown", dann gilt er als "default".
1233 	3. Es gelten fuer Vergleiche die Werte der "default"-Items.
1234 
1235 1.-Item     2.-Item     Values  bIgnoreDefs     Remove      Assign      Add
1236 
1237 set         set         ==      sal_False           -           -           -
1238 default     set         ==      sal_False           -           -           -
1239 dontcare    set         ==      sal_False           -           -           -
1240 unknown     set         ==      sal_False           -           -           -
1241 set         default     ==      sal_False           -           -           -
1242 default     default     ==      sal_False           -           -           -
1243 dontcare    default     ==      sal_False           -           -           -
1244 unknown     default     ==      sal_False           -           -           -
1245 set         dontcare    ==      sal_False           1.-Item     -1          -
1246 default 	dontcare	==		sal_False			-			-1			-
1247 dontcare    dontcare    ==      sal_False           -           -           -
1248 unknown     dontcare    ==      sal_False           -           -           -
1249 set         unknown     ==      sal_False           1.-Item     -1          -
1250 default     unknown     ==      sal_False           -           -           -
1251 dontcare    unknown     ==      sal_False           -           -           -
1252 unknown     unknown     ==      sal_False           -           -           -
1253 
1254 set         set         !=      sal_False           1.-Item     -1          -
1255 default     set         !=      sal_False           -           -1          -
1256 dontcare    set         !=      sal_False           -           -           -
1257 unknown     set         !=      sal_False           -           -           -
1258 set         default     !=      sal_False           1.-Item     -1          -
1259 default     default     !=      sal_False           -           -           -
1260 dontcare    default     !=      sal_False           -           -           -
1261 unknown     default     !=      sal_False           -           -           -
1262 set         dontcare    !=      sal_False           1.-Item     -1          -
1263 default     dontcare    !=      sal_False           -           -1          -
1264 dontcare    dontcare    !=      sal_False           -           -           -
1265 unknown     dontcare    !=      sal_False           -           -           -
1266 set         unknown     !=      sal_False           1.-Item     -1          -
1267 default     unknown     !=      sal_False           -           -           -
1268 dontcare    unknown     !=      sal_False           -           -           -
1269 unknown     unknown     !=      sal_False           -           -           -
1270 
1271 set         set         ==      sal_True            -           -           -
1272 default 	set 		==		sal_True			-			2.-Item 	2.-Item
1273 dontcare    set         ==      sal_True            -           -           -
1274 unknown     set         ==      sal_True            -           -           -
1275 set         default     ==      sal_True            -           -           -
1276 default     default     ==      sal_True            -           -           -
1277 dontcare    default     ==      sal_True            -           -           -
1278 unknown     default     ==      sal_True            -           -           -
1279 set         dontcare    ==      sal_True            -           -           -
1280 default 	dontcare	==		sal_True			-			-1			-
1281 dontcare    dontcare    ==      sal_True            -           -           -
1282 unknown     dontcare    ==      sal_True            -           -           -
1283 set         unknown     ==      sal_True            -           -           -
1284 default     unknown     ==      sal_True            -           -           -
1285 dontcare    unknown     ==      sal_True            -           -           -
1286 unknown     unknown     ==      sal_True            -           -           -
1287 
1288 set         set         !=      sal_True            1.-Item     -1          -
1289 default     set         !=      sal_True            -           2.-Item     2.-Item
1290 dontcare	set 		!=		sal_True			-			-			-
1291 unknown     set         !=      sal_True            -           -           -
1292 set         default     !=      sal_True            -           -           -
1293 default     default     !=      sal_True            -           -           -
1294 dontcare    default     !=      sal_True            -           -           -
1295 unknown     default     !=      sal_True            -           -           -
1296 set         dontcare    !=      sal_True            1.-Item     -1          -
1297 default     dontcare    !=      sal_True            -           -1          -
1298 dontcare    dontcare    !=      sal_True            -           -           -
1299 unknown     dontcare    !=      sal_True            -           -           -
1300 set         unknown     !=      sal_True            -           -           -
1301 default     unknown     !=      sal_True            -           -           -
1302 dontcare    unknown     !=      sal_True            -           -           -
1303 unknown     unknown     !=      sal_True            -           -           -
1304 */
1305 
1306 
MergeItem_Impl(SfxItemPool * _pPool,sal_uInt16 & rCount,const SfxPoolItem ** ppFnd1,const SfxPoolItem * pFnd2,sal_Bool bIgnoreDefaults)1307 static void MergeItem_Impl( SfxItemPool *_pPool, sal_uInt16 &rCount,
1308 							const SfxPoolItem **ppFnd1, const SfxPoolItem *pFnd2,
1309 							sal_Bool bIgnoreDefaults )
1310 {
1311 	DBG_ASSERT( ppFnd1 != 0, "Merging to 0-Item" );
1312 
1313 	// 1. Item ist default?
1314 	if ( !*ppFnd1 )
1315 	{
1316 		if ( IsInvalidItem(pFnd2) )
1317 			// Entscheidungstabelle: default, dontcare, egal, egal
1318 			*ppFnd1 = (SfxPoolItem*) -1;
1319 
1320 		else if ( pFnd2 && !bIgnoreDefaults &&
1321 				  _pPool->GetDefaultItem(pFnd2->Which()) != *pFnd2 )
1322 			// Entscheidungstabelle: default, set, !=, sal_False
1323 			*ppFnd1 = (SfxPoolItem*) -1;
1324 
1325 		else if ( pFnd2 && bIgnoreDefaults )
1326 			// Entscheidungstabelle: default, set, egal, sal_True
1327 			*ppFnd1 = &_pPool->Put( *pFnd2 );
1328 
1329 		if ( *ppFnd1 )
1330 			++rCount;
1331 	}
1332 
1333 	// 1. Item ist gesetzt?
1334 	else if ( !IsInvalidItem(*ppFnd1) )
1335 	{
1336 		if ( !pFnd2 )
1337 		{
1338 			// 2. Item ist default
1339 			if ( !bIgnoreDefaults &&
1340 				 **ppFnd1 != _pPool->GetDefaultItem((*ppFnd1)->Which()) )
1341 			{
1342 				// Entscheidungstabelle: set, default, !=, sal_False
1343 				_pPool->Remove( **ppFnd1 );
1344 				*ppFnd1 = (SfxPoolItem*) -1;
1345 			}
1346 		}
1347 		else if ( IsInvalidItem(pFnd2) )
1348 		{
1349 			// 2. Item ist dontcare
1350 			if ( !bIgnoreDefaults ||
1351 				 **ppFnd1 != _pPool->GetDefaultItem( (*ppFnd1)->Which()) )
1352 			{
1353 				// Entscheidungstabelle: set, dontcare, egal, sal_False
1354 				// oder:				 set, dontcare, !=, sal_True
1355 				_pPool->Remove( **ppFnd1 );
1356 				*ppFnd1 = (SfxPoolItem*) -1;
1357 			}
1358 		}
1359 		else
1360 		{
1361 			// 2. Item ist gesetzt
1362 			if ( **ppFnd1 != *pFnd2 )
1363 			{
1364 				// Entscheidungstabelle: set, set, !=, egal
1365 				_pPool->Remove( **ppFnd1 );
1366 				*ppFnd1 = (SfxPoolItem*) -1;
1367 			}
1368 		}
1369 	}
1370 }
1371 
1372 // -----------------------------------------------------------------------
1373 
MergeValues(const SfxItemSet & rSet,sal_Bool bIgnoreDefaults)1374 void SfxItemSet::MergeValues( const SfxItemSet& rSet, sal_Bool bIgnoreDefaults )
1375 {
1376 	// Achtung!!! Bei Aenderungen/Bugfixes immer obenstehende Tabelle pflegen!
1377 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1378 	DBG_ASSERT( GetPool() == rSet.GetPool(), "MergeValues mit verschiedenen Pools" );
1379 
1380 	// teste mal, ob sich die Which-Bereiche unterscheiden.
1381 	sal_Bool bEqual = sal_True;
1382 	sal_uInt16* pWh1 = _pWhichRanges;
1383 	sal_uInt16* pWh2 = rSet._pWhichRanges;
1384 	sal_uInt16 nSize = 0;
1385 
1386 	for( sal_uInt16 n = 0; *pWh1 && *pWh2; ++pWh1, ++pWh2, ++n )
1387 	{
1388 		if( *pWh1 != *pWh2 )
1389 		{
1390 			bEqual = sal_False;
1391 			break;
1392 		}
1393 		if( n & 1 )
1394 			nSize += ( *(pWh1) - *(pWh1-1) ) + 1;
1395 	}
1396 	bEqual = *pWh1 == *pWh2; // auch die 0 abpruefen
1397 
1398 	// sind die Bereiche identisch, ist es effizieter zu handhaben !
1399 	if( bEqual )
1400 	{
1401 		SfxItemArray ppFnd1 = _aItems;
1402 		SfxItemArray ppFnd2 = rSet._aItems;
1403 
1404 		for( ; nSize; --nSize, ++ppFnd1, ++ppFnd2 )
1405 			MergeItem_Impl( _pPool, _nCount, ppFnd1, *ppFnd2, bIgnoreDefaults );
1406 	}
1407 	else
1408 	{
1409 		SfxWhichIter aIter( rSet );
1410 		register sal_uInt16 nWhich;
1411 		while( 0 != ( nWhich = aIter.NextWhich() ) )
1412 		{
1413 			const SfxPoolItem* pItem = 0;
1414 			rSet.GetItemState( nWhich, sal_True, &pItem );
1415 			if( !pItem )
1416 			{
1417 				// nicht gesetzt, also default
1418 				if ( !bIgnoreDefaults )
1419 					MergeValue( rSet.GetPool()->GetDefaultItem( nWhich ), bIgnoreDefaults );
1420 			}
1421 			else if( IsInvalidItem( pItem ) )
1422 				// dont care
1423 				InvalidateItem( nWhich );
1424 			else
1425 				MergeValue( *pItem, bIgnoreDefaults );
1426 		}
1427 	}
1428 	InvalidateHashKey();	//i120575
1429 }
1430 
1431 // -----------------------------------------------------------------------
1432 
MergeValue(const SfxPoolItem & rAttr,sal_Bool bIgnoreDefaults)1433 void SfxItemSet::MergeValue( const SfxPoolItem& rAttr, sal_Bool bIgnoreDefaults )
1434 {
1435 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1436 	SfxItemArray ppFnd = _aItems;
1437 	const sal_uInt16* pPtr = _pWhichRanges;
1438 	const sal_uInt16 nWhich = rAttr.Which();
1439 	while( *pPtr )
1440 	{
1441 		// in diesem Bereich?
1442 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1443 		{
1444 			ppFnd += nWhich - *pPtr;
1445 			MergeItem_Impl( _pPool, _nCount, ppFnd, &rAttr, bIgnoreDefaults );
1446 			break;
1447 		}
1448 		ppFnd += *(pPtr+1) - *pPtr + 1;
1449 		pPtr += 2;
1450 	}
1451 	InvalidateHashKey();	//i120575
1452 }
1453 
1454 // -----------------------------------------------------------------------
1455 
InvalidateItem(sal_uInt16 nWhich)1456 void SfxItemSet::InvalidateItem( sal_uInt16 nWhich )
1457 {
1458 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1459 	SfxItemArray ppFnd = _aItems;
1460 	const sal_uInt16* pPtr = _pWhichRanges;
1461 	while( *pPtr )
1462 	{
1463 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1464 		{
1465 			// in diesem Bereich
1466 			ppFnd += nWhich - *pPtr;
1467 
1468 			if( *ppFnd )   	// bei mir gesetzt
1469 			{
1470 				if( (SfxPoolItem*)-1 != *ppFnd )		// noch nicht dontcare !
1471 				{
1472 					_pPool->Remove( **ppFnd );
1473 					*ppFnd = (SfxPoolItem*)-1;
1474 				}
1475 			}
1476 			else
1477 			{
1478 				*ppFnd = (SfxPoolItem*)-1;
1479 				++_nCount;
1480 			}
1481 			break;
1482 		}
1483 		ppFnd += *(pPtr+1) - *pPtr + 1;
1484 		pPtr += 2;
1485 	}
1486 	InvalidateHashKey();	//i120575
1487 }
1488 
1489 // -----------------------------------------------------------------------
1490 
GetWhichByPos(sal_uInt16 nPos) const1491 sal_uInt16 SfxItemSet::GetWhichByPos( sal_uInt16 nPos ) const
1492 {
1493 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1494 	sal_uInt16 n = 0;
1495 	sal_uInt16* pPtr  = _pWhichRanges;
1496 	while( *pPtr )
1497 	{
1498 		n = ( *(pPtr+1) - *pPtr ) + 1;
1499 		if( nPos < n )
1500 			return *(pPtr)+nPos;
1501 		nPos = nPos - n;
1502 		pPtr += 2;
1503 	}
1504 	DBG_ASSERT( sal_False, "Hier sind wir falsch" );
1505 	return 0;
1506 }
1507 
1508 // -----------------------------------------------------------------------
1509 
Store(SvStream & rStream,FASTBOOL bDirect) const1510 SvStream &SfxItemSet::Store
1511 (
1512 	SvStream&	rStream,		// Zielstream f"ur normale Items
1513 	FASTBOOL	bDirect 		// sal_True: Items direkt speicher, sal_False: Surrogate
1514 )	const
1515 
1516 /*	[Beschreibung]
1517 
1518 	Speichert die <SfxItemSet>-Instanz in den angegebenen Stream. Dabei
1519 	werden die Surrorage der gesetzten <SfxPoolItem>s bzw. ('bDirect==sal_True')
1520 	die gesetzten Items selbst wie folgt im Stream abgelegt:
1521 
1522 			sal_uInt16				(Count) Anzahl der gesetzten Items
1523 	Count*	_pPool->StoreItem()  siehe <SfxItemPool::StoreItem()const>
1524 
1525 
1526 	[Querverweise]
1527 
1528 	<SfxItemSet::Load(SvStream&,sal_Bool,const SfxItemPool*)>
1529 */
1530 
1531 {
1532 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1533 	DBG_ASSERT( _pPool, "Kein Pool" );
1534 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "kein Master-Pool" );
1535 
1536 	// Position des Counts merken, um ggf. zu korrigieren
1537 	sal_uLong nCountPos = rStream.Tell();
1538 	rStream << _nCount;
1539 
1540 	// wenn nichts zu speichern ist, auch keinen ItemIter aufsetzen!
1541 	if ( _nCount )
1542 	{
1543 		// mitz"ahlen wieviel Items tats"achlich gespeichert werden
1544 		sal_uInt16 nWrittenCount = 0;  // Anzahl in 'rStream' gestreamter Items
1545 
1546 		// "uber alle gesetzten Items iterieren
1547 		SfxItemIter aIter(*this);
1548 		for ( const SfxPoolItem *pItem = aIter.FirstItem();
1549 			  pItem;
1550 			  pItem = aIter.NextItem() )
1551 		{
1552 			// Item (ggf. als Surrogat) via Pool speichern lassen
1553 			DBG_ASSERT( !IsInvalidItem(pItem), "can't store invalid items" );
1554 			if ( !IsInvalidItem(pItem) &&
1555 				 _pPool->StoreItem( rStream, *pItem, bDirect ) )
1556 				// Item wurde in 'rStream' gestreamt
1557 				++nWrittenCount;
1558 		};
1559 
1560 		// weniger geschrieben als enthalten (z.B. altes Format)
1561 		if ( nWrittenCount != _nCount )
1562 		{
1563 			// tats"achlichen Count im Stream ablegen
1564 			sal_uLong nPos = rStream.Tell();
1565 			rStream.Seek( nCountPos );
1566 			rStream << nWrittenCount;
1567 			rStream.Seek( nPos );
1568 		}
1569 	}
1570 
1571 	return rStream;
1572 }
1573 
1574 // -----------------------------------------------------------------------
1575 
Load(SvStream & rStream,FASTBOOL bDirect,const SfxItemPool * pRefPool)1576 SvStream &SfxItemSet::Load
1577 (
1578 	SvStream&			rStream,	//	Stream, aus dem geladen werden soll
1579 
1580 	FASTBOOL			bDirect,	/*	sal_True
1581 										Items werden direkt aus dem Stream
1582 										gelesen, nicht "uber Surrogate
1583 
1584 										sal_False (default)
1585 										Items werden "uber Surrogate gelesen */
1586 
1587 	const SfxItemPool*	pRefPool 	/*	Pool, der die Surrogate aufl"osen kann
1588 										(z.B. zum Einf"ugen von Dokumenten) */
1589 )
1590 
1591 /*	[Beschreibung]
1592 
1593 	Diese Methode l"adt ein <SfxItemSet> aus einem Stream. Falls der
1594 	<SfxItemPool> ohne Ref-Counts geladen wurde, werden die geladenen
1595 	Item-Referenzen in den Items hochgez"ahlt, ansonsten wird vorausgesetzt,
1596 	da\s sie schon beim Laden des SfxItemPools ber"ucksichtigt waren.
1597 
1598 	[Querverweise]
1599 
1600 	<SfxItemSet::Store(Stream&,sal_Bool)const>
1601 */
1602 
1603 {
1604 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1605 	DBG_ASSERT( _pPool, "Kein Pool");
1606 	DBG_ASSERTWARNING( _pPool == _pPool->GetMasterPool(), "Kein Master-Pool");
1607 
1608 	// kein Ref-Pool => Surrogate mit Pool des ItemSets aufl"osen
1609 	if ( !pRefPool )
1610 		pRefPool = _pPool;
1611 
1612 	// Anzahl der zu ladenden Items laden und dann ebensoviele Items
1613 	sal_uInt16 nCount = 0;
1614 	rStream >> nCount;
1615 	for ( sal_uInt16 i = 0; i < nCount; ++i )
1616 	{
1617 		// Surrogat/Item laden und (Surrogat) aufl"osen lassen
1618 		const SfxPoolItem *pItem =
1619 				_pPool->LoadItem( rStream, bDirect, pRefPool );
1620 
1621 		// konnte ein Item geladen oder via Surrogat aufgel"ost werden?
1622 		if ( pItem )
1623 		{
1624 			// Position f"ur Item-Pointer im Set suchen
1625 			sal_uInt16 nWhich = pItem->Which();
1626 			SfxItemArray ppFnd = _aItems;
1627 			const sal_uInt16* pPtr = _pWhichRanges;
1628 			while ( *pPtr )
1629 			{
1630 				// in diesem Bereich?
1631 				if ( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1632 				{
1633 					// Item-Pointer im Set merken
1634 					ppFnd += nWhich - *pPtr;
1635 					SFX_ASSERT( !*ppFnd, nWhich, "Item doppelt eingetragen");
1636 					*ppFnd = pItem;
1637 					++_nCount;
1638 					break;
1639 				}
1640 
1641 				// im Range-Array und Item-Array zum n"achsten Which-Range
1642 				ppFnd += *(pPtr+1) - *pPtr + 1;
1643 				pPtr += 2;
1644 			}
1645 		}
1646 	}
1647 
1648 
1649 	InvalidateHashKey();	//i120575
1650 	return rStream;
1651 }
1652 
1653 // -----------------------------------------------------------------------
1654 
operator ==(const SfxItemSet & rCmp) const1655 int	SfxItemSet::operator==(const SfxItemSet &rCmp) const
1656 {
1657 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1658 	DBG_CHKOBJ(&rCmp, SfxItemSet, DbgCheckItemSet);
1659 
1660 	// besonders schnell zu ermittelnde Werte muessen gleich sein
1661 	if ( _pParent != rCmp._pParent ||
1662 		 _pPool != rCmp._pPool ||
1663 		 Count() != rCmp.Count() )
1664 		return sal_False;
1665 
1666 	// Ranges durchzaehlen lassen dauert laenger, muss aber auch gleich sein
1667 	sal_uInt16 nCount1 = TotalCount();
1668 	sal_uInt16 nCount2 = rCmp.TotalCount();
1669 	if ( nCount1 != nCount2 )
1670 		return sal_False;
1671 
1672 	// sind die Ranges selbst ungleich?
1673 	for ( sal_uInt16 nRange = 0; _pWhichRanges[nRange]; nRange += 2 )
1674 		if ( _pWhichRanges[nRange] != rCmp._pWhichRanges[nRange] ||
1675 			 _pWhichRanges[nRange+1] != rCmp._pWhichRanges[nRange+1] )
1676 		{
1677 			// dann m"ussen wir die langsame Methode verwenden
1678 			SfxWhichIter aIter( *this );
1679 			for ( sal_uInt16 nWh = aIter.FirstWhich();
1680 				  nWh;
1681 				  nWh = aIter.NextWhich() )
1682 			{
1683 				// wenn die Pointer von poolable Items ungleich sind,
1684 				// muessen die Items gleich sein
1685 				const SfxPoolItem *pItem1 = 0, *pItem2 = 0;
1686 				if ( GetItemState( nWh, sal_False, &pItem1 ) !=
1687 						rCmp.GetItemState( nWh, sal_False, &pItem2 ) ||
1688 					 ( pItem1 != pItem2 &&
1689 						( !pItem1 || IsInvalidItem(pItem1) ||
1690 						  ( _pPool->IsItemFlag(*pItem1, SFX_ITEM_POOLABLE) &&
1691 							*pItem1 != *pItem2 ) ) ) )
1692 					return sal_False;
1693 			}
1694 
1695 			return sal_True;
1696 		}
1697 
1698 	// Pointer alle gleich?
1699 	if ( 0 == memcmp( _aItems, rCmp._aItems, nCount1 * sizeof(_aItems[0]) ) )
1700 		return sal_True;
1701 
1702 	// dann werden wir wohl alle einzeln vergleichen muessen
1703 	const SfxPoolItem **ppItem1 = (const SfxPoolItem**) _aItems;
1704 	const SfxPoolItem **ppItem2 = (const SfxPoolItem**) rCmp._aItems;
1705 	for ( sal_uInt16 nPos = 0; nPos < nCount1; ++nPos )
1706 	{
1707 		// wenn die Pointer von poolable Items ungleich sind,
1708 		// muessen die Items gleich sein
1709 		if ( *ppItem1 != *ppItem2 &&
1710 			 ( ( !*ppItem1 || !*ppItem2 ) ||
1711 			   ( IsInvalidItem(*ppItem1) || IsInvalidItem(*ppItem2) ) ||
1712 			   ( _pPool->IsItemFlag(**ppItem1, SFX_ITEM_POOLABLE) ) ||
1713 				 **ppItem1 != **ppItem2 ) )
1714 			return sal_False;
1715 
1716 		++ppItem1;
1717 		++ppItem2;
1718 	}
1719 
1720 	return sal_True;
1721 }
1722 
1723 // -----------------------------------------------------------------------
1724 
Clone(sal_Bool bItems,SfxItemPool * pToPool) const1725 SfxItemSet *SfxItemSet::Clone(sal_Bool bItems, SfxItemPool *pToPool ) const
1726 {
1727 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1728 	if ( pToPool && pToPool != _pPool )
1729 	{
1730 		SfxItemSet *pNewSet = new SfxItemSet( *pToPool, _pWhichRanges );
1731 		if ( bItems )
1732 		{
1733 			SfxWhichIter aIter(*pNewSet);
1734 			sal_uInt16 nWhich = aIter.FirstWhich();
1735 			while ( nWhich )
1736 			{
1737 				const SfxPoolItem* pItem;
1738 				if ( SFX_ITEM_SET == GetItemState( nWhich, sal_False, &pItem ) )
1739 					pNewSet->Put( *pItem, pItem->Which() );
1740 				nWhich = aIter.NextWhich();
1741 			}
1742 		}
1743 		return pNewSet;
1744 	}
1745 	else
1746 		return bItems
1747 				? new SfxItemSet(*this)
1748 				: new SfxItemSet(*_pPool, _pWhichRanges);
1749 }
1750 
1751 // -----------------------------------------------------------------------
1752 
PutDirect(const SfxPoolItem & rItem)1753 int	SfxItemSet::PutDirect(const SfxPoolItem &rItem)
1754 {
1755 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
1756 	SfxItemArray ppFnd = _aItems;
1757 	const sal_uInt16* pPtr = _pWhichRanges;
1758 	const sal_uInt16 nWhich = rItem.Which();
1759 #ifdef DBG_UTIL
1760 	IsPoolDefaultItem(&rItem) || _pPool->GetSurrogate(&rItem);
1761 		// nur Assertion in den callees provozieren
1762 #endif
1763 	while( *pPtr )
1764 	{
1765 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1766 		{
1767 			// in diesem Bereich
1768 			ppFnd += nWhich - *pPtr;
1769 			const SfxPoolItem* pOld = *ppFnd;
1770 			if( pOld )		// schon einer vorhanden
1771 			{
1772 				if( rItem == **ppFnd )
1773 					return sal_False;		// schon vorhanden !
1774 				_pPool->Remove( *pOld );
1775 			}
1776 			else
1777 				++_nCount;
1778 
1779 			// den neuen eintragen
1780 			if( IsPoolDefaultItem(&rItem) )
1781 				*ppFnd = &_pPool->Put( rItem );
1782 			else
1783 			{
1784 				*ppFnd = &rItem;
1785 				if( !IsStaticDefaultItem( &rItem ) )
1786 					rItem.AddRef();
1787 			}
1788 
1789 			InvalidateHashKey();	//i120575
1790 			return sal_True;
1791 		}
1792 		ppFnd += *(pPtr+1) - *pPtr + 1;
1793 		pPtr += 2;
1794 	}
1795 	return sal_False;
1796 }
1797 
1798 // -----------------------------------------------------------------------
1799 
SfxAllItemSet(SfxItemPool & rPool)1800 SfxAllItemSet::SfxAllItemSet( SfxItemPool &rPool )
1801 :	SfxItemSet(rPool, (const sal_uInt16*) 0),
1802 	aDefault(0),
1803 	nFree(nInitCount)
1804 {
1805 	// initial keine Items
1806 	_aItems = 0;
1807 
1808 	// nInitCount Paare an USHORTs fuer Ranges allozieren
1809 	_pWhichRanges = new sal_uInt16[ nInitCount + 1 ];
1810 	memset( _pWhichRanges, 0, ( nInitCount + 1 ) * sizeof(sal_uInt16) );
1811 }
1812 
1813 
1814 // -----------------------------------------------------------------------
1815 
1816 
SfxAllItemSet(const SfxItemSet & rCopy)1817 SfxAllItemSet::SfxAllItemSet(const SfxItemSet &rCopy)
1818 :   SfxItemSet(rCopy),
1819 	aDefault(0),
1820 	nFree(0)
1821 {
1822 }
1823 
1824 // -----------------------------------------------------------------------
1825 
1826 
1827 
SfxAllItemSet(const SfxAllItemSet & rCopy)1828 SfxAllItemSet::SfxAllItemSet(const SfxAllItemSet &rCopy)
1829 :   SfxItemSet(rCopy),
1830 	aDefault(0),
1831 	nFree(0)
1832 /*	[Anmerkung]
1833 
1834 	Der mu\s sein, da sonst vom Compiler einer generiert wird, er nimmt
1835 	nicht den Ctor mit der 'const SfxItemSet&'!
1836 */
1837 {
1838 }
1839 
1840 // -----------------------------------------------------------------------
1841 
AddRanges_Impl(sal_uInt16 * pUS,std::ptrdiff_t nOldSize,sal_uInt16 nIncr)1842 static sal_uInt16 *AddRanges_Impl(
1843     sal_uInt16 *pUS, std::ptrdiff_t nOldSize, sal_uInt16 nIncr)
1844 
1845 /* 	Diese interne Funktion erzeugt ein neues Which-Range-Array, welches von
1846     dem 'nOldSize'-USHORTs langen 'pUS' kopiert wird und hinten an Platz
1847     f"ur 'nIncr' neue USHORTs hat. Das terminierende sal_uInt16 mit der '0'
1848     wird weder in 'nOldSize' noch in 'nIncr' mitgez"ahlt, sondern implizit
1849 	hinzugerechnet.
1850 
1851 	Das neue Which-Range-Array wird als Returnwert zur"uckgegeben, das alte
1852     'pUS' freigegeben.
1853 */
1854 
1855 {
1856 	// neues Which-Range-Array anlegen
1857 	sal_uInt16 *pNew = new sal_uInt16[ nOldSize + nIncr + 1 ];
1858 
1859 	// die alten Ranges "ubernehmen
1860 	memcpy( pNew, pUS, nOldSize * sizeof(sal_uInt16) );
1861 
1862 	// die neuen auf 0 initialisieren
1863 	memset( pNew + nOldSize, 0, ( nIncr + 1 ) * sizeof(sal_uInt16) );
1864 
1865 	// das alte Array freigeben
1866 	delete[] pUS;
1867 
1868 	return pNew;
1869 }
1870 
1871 // -----------------------------------------------------------------------
1872 
AddItem_Impl(SfxItemArray pItems,sal_uInt16 nOldSize,sal_uInt16 nPos)1873 static SfxItemArray AddItem_Impl(SfxItemArray pItems, sal_uInt16 nOldSize, sal_uInt16 nPos)
1874 
1875 /*  Diese interne Funktion erzeugt ein neues ItemArray, welches von 'pItems'
1876     kopiert wird, an der Position 'nPos' jedoch Platz f"ur einen neuen
1877 	ItemPointer hat.
1878 
1879     Das neue ItemArray wird als Returnwert zur"uckgegeben, das alte 'pItems'
1880 	wird freigegeben.
1881 */
1882 
1883 {
1884 	// neues ItemArray anlegen
1885 	SfxItemArray pNew = new const SfxPoolItem*[nOldSize+1];
1886 
1887 	// war schon vorher eins da?
1888 	if ( pItems )
1889 	{
1890 		// alte Items vor nPos kopieren
1891 		if ( nPos )
1892 			memcpy( (void*) pNew, pItems, nPos * sizeof(SfxPoolItem **) );
1893 
1894 		// alte Items hinter nPos kopieren
1895 		if ( nPos < nOldSize )
1896 			memcpy( (void*) (pNew + nPos + 1), pItems + nPos,
1897 					(nOldSize-nPos) * sizeof(SfxPoolItem **) );
1898 	}
1899 
1900 	// neues Item initialisieren
1901 	*(pNew + nPos) = 0;
1902 
1903 	// altes ItemArray freigeben
1904 	delete[] pItems;
1905 
1906 	return pNew;
1907 }
1908 
1909 // -----------------------------------------------------------------------
1910 
Put(const SfxPoolItem & rItem,sal_uInt16 nWhich)1911 const SfxPoolItem* SfxAllItemSet::Put( const SfxPoolItem& rItem, sal_uInt16 nWhich )
1912 
1913 // Putten mit automatischer Erweiterung der Whichs-Ids um die ID
1914 // des Items.
1915 
1916 {
1917     sal_uInt16 nPos = 0; // Position f"ur 'rItem' in '_aItems'
1918 	const sal_uInt16 nItemCount = TotalCount();
1919 
1920 	// erstmal sehen, ob es schon einen passenden Bereich gibt
1921 	sal_uInt16 *pPtr = _pWhichRanges;
1922 	while ( *pPtr )
1923 	{
1924 		// Which-Id liegt in diesem Bereich?
1925 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
1926 		{
1927 			// Einfuegen
1928 			nPos += nWhich - *pPtr;
1929 			break;
1930 		}
1931 
1932 		// Position des Items in _aItems mitf"uhren
1933 		nPos += *(pPtr+1) - *pPtr + 1;
1934 
1935 		// zum n"achsten Bereich
1936 		pPtr += 2;
1937 	}
1938 
1939 	// Which-Id noch nicht vorhanden?
1940 	if ( !*pPtr )
1941 	{
1942 		// suchen, ob man sie irgendwo dranpacken kann
1943 		pPtr = _pWhichRanges;
1944 		nPos = 0;
1945 		while ( *pPtr )
1946 		{
1947 			// Which-Id liegt exakt vor diesem Bereich?
1948 			if ( (nWhich+1) == *pPtr )
1949 			{
1950 				// Bereich waechst nach unten
1951 				(*pPtr)--;
1952 
1953 				// vor erstem Item dieses Bereichs Platz schaffen
1954 				_aItems = AddItem_Impl(_aItems, nItemCount, nPos);
1955 				break;
1956 			}
1957 
1958 			// Which-Id liegt exakt hinter diesem Bereich?
1959 			else if ( (nWhich-1) == *(pPtr+1) )
1960 			{
1961 				// Bereich waechst nach oben
1962 				(*(pPtr+1))++;
1963 
1964 				// hinter letztem Item dieses Bereichs Platz schaffen
1965 				nPos += nWhich - *pPtr;
1966 				_aItems = AddItem_Impl(_aItems, nItemCount, nPos);
1967 				break;
1968 			}
1969 
1970 			// Position des Items in _aItems mitf"uhren
1971 			nPos += *(pPtr+1) - *pPtr + 1;
1972 
1973 			// zum n"achsten Bereich
1974 			pPtr += 2;
1975 		}
1976 	}
1977 
1978 	// keinen erweiterbaren Bereich gefunden?
1979 	if ( !*pPtr )
1980 	{
1981 		// kein Platz mehr in _pWhichRanges => erweitern
1982 		std::ptrdiff_t nSize = pPtr - _pWhichRanges;
1983 		if( !nFree )
1984 		{
1985 			_pWhichRanges = AddRanges_Impl(_pWhichRanges, nSize, nInitCount);
1986 			nFree += nInitCount;
1987 		}
1988 
1989 		// neuen Which-Range anh"angen
1990 		pPtr = _pWhichRanges + nSize;
1991 		*pPtr++ = nWhich;
1992 		*pPtr = nWhich;
1993 		nFree -= 2;
1994 
1995 		// Itemarray vergroessern
1996 		nPos = nItemCount;
1997 		_aItems = AddItem_Impl(_aItems, nItemCount, nPos);
1998 	}
1999 
2000 	// neues Item in Pool aufnehmen
2001 	const SfxPoolItem& rNew = _pPool->Put( rItem, nWhich );
2002 
2003 	// altes Item merken
2004     sal_Bool bIncrementCount = sal_False;
2005 	const SfxPoolItem* pOld = *( _aItems + nPos );
2006     if ( reinterpret_cast< SfxPoolItem* >( -1 ) == pOld )   // state "dontcare"
2007         pOld = NULL;
2008     if ( !pOld )
2009     {
2010         bIncrementCount = sal_True;
2011         pOld = _pParent ?
2012                 &_pParent->Get( nWhich, sal_True )
2013                 : nWhich <= SFX_WHICH_MAX ? &_pPool->GetDefaultItem( nWhich ) : 0;
2014     }
2015 
2016 	// neue Item in ItemSet aufnehmen
2017 	*(_aItems + nPos) = &rNew;
2018 
2019 	// Changed Notification versenden
2020 	if ( pOld )
2021 	{
2022 		Changed( *pOld, rNew );
2023 		if ( !IsDefaultItem(pOld) )
2024 			_pPool->Remove( *pOld );
2025 	}
2026 
2027     if ( bIncrementCount )
2028         ++_nCount;
2029 
2030 	InvalidateHashKey();	//i120575
2031 
2032 	return &rNew;
2033 }
2034 
2035 // -----------------------------------------------------------------------
2036 
2037 
2038 /*	Diese Methode wird forwarded, damit sie nicht durch die anderen
2039 	Put-Methoden dieser SubClass gehided wird.
2040 */
2041 
Put(const SfxItemSet & rSet,sal_Bool bInvalidAsDefault)2042 int SfxAllItemSet::Put( const SfxItemSet& rSet, sal_Bool bInvalidAsDefault )
2043 {
2044 	//? pruefen, ob Which-Ranges erweitert werden
2045 	return SfxItemSet::Put( rSet, bInvalidAsDefault );
2046 }
2047 
2048 // -----------------------------------------------------------------------
2049 // Item disablen, wenn durch ein VoidItem mit dem Which-Wert 0 ausgedrueckt
2050 
DisableItem(sal_uInt16 nWhich)2051 void SfxItemSet::DisableItem(sal_uInt16 nWhich)
2052 {
2053 	DBG_CHKTHIS(SfxItemSet, 0);
2054 	Put( SfxVoidItem(0), nWhich );
2055 }
2056 
2057 // -----------------------------------------------------------------------
2058 
2059 #if 0
2060 sal_Bool SfxAllItemSet::Remove(sal_uInt16 nWhich)
2061 {
2062 	DBG_CHKTHIS(SfxAllItemSet, 0);
2063 	sal_uInt16 *pPtr = _pWhichRanges;
2064 	sal_uInt16 nPos = 0;
2065 	while( *pPtr )
2066 	{
2067 		if( *pPtr <= nWhich && nWhich <= *(pPtr+1) )
2068 		{
2069 			sal_uInt16 *pTmp = pPtr;
2070 			sal_uInt16 nLeft = 0;
2071 			sal_uInt16 nRest = 0;
2072 			while(*++pTmp){
2073 				if( nLeft & 1 )
2074 					nRest = *pTmp - *(pTmp-1) + 1;
2075 				++nLeft;
2076 			}
2077 
2078 			// in diesem Bereich
2079 			nPos += nWhich - *pPtr;
2080 			nRest -= nWhich - *pPtr;
2081 			// 3,3
2082 			if(*pPtr == nWhich && *(pPtr+1) == nWhich) {
2083 				memmove(pPtr, pPtr + 2, nLeft * sizeof(sal_uInt16));
2084 				nFree += 2;
2085 			}
2086 				// Anfang
2087 			else if(*pPtr == nWhich)
2088 				(*pPtr)++;
2089 				// Ende
2090 			else if(*(pPtr+1) == nWhich)
2091 				(*(pPtr+1))--;
2092 			else {
2093 				if(nPos + nRest + 2 > nFree) {
2094 					sal_uInt16 nOf = pPtr - _pWhichRanges;
2095 					_pWhichRanges = IncrSize(_pWhichRanges, nPos + nRest, nInitCount);
2096 					nFree += nInitCount;
2097 					pPtr = _pWhichRanges + nOf;
2098 				}
2099 				memmove(pPtr +2, pPtr, (nLeft+2) * sizeof(sal_uInt16));
2100 				*++pPtr  = nWhich-1;
2101 				*++pPtr = nWhich+1;
2102 				nFree -= 2;
2103 			}
2104 			SfxPoolItem* pItem = *( _aItems + nPos );
2105 			if( pItem )
2106 			{
2107 				if(_pPool)
2108 					_pPool->Remove(*pItem );
2109 				else
2110 					delete pItem;
2111 				--_nCount;
2112 			}
2113 			memmove(_aItems + nPos +1, _aItems + nPos,
2114 					sizeof(SfxPoolItem *) * (nRest - 1));
2115 			break; 			// dann beim Parent suchen
2116 		}
2117 		nPos += *(pPtr+1) - *pPtr + 1;
2118 		pPtr += 2;
2119 	}
2120 	return *pPtr? sal_True: sal_False;
2121 }
2122 #endif
2123 
2124 // -----------------------------------------------------------------------
2125 
Clone(sal_Bool bItems,SfxItemPool * pToPool) const2126 SfxItemSet *SfxAllItemSet::Clone(sal_Bool bItems, SfxItemPool *pToPool ) const
2127 {
2128 	DBG_CHKTHIS(SfxItemSet, DbgCheckItemSet);
2129 	if ( pToPool && pToPool != _pPool )
2130 	{
2131 		SfxAllItemSet *pNewSet = new SfxAllItemSet( *pToPool );
2132 		if ( bItems )
2133 			pNewSet->Set( *this );
2134 		return pNewSet;
2135 	}
2136 	else
2137 		return bItems ? new SfxAllItemSet(*this) : new SfxAllItemSet(*_pPool);
2138 }
2139 
2140 //for i120575
2141 //align with the rtl_hash, return signed int result and input len limited to 2G.
2142 //can be replaced with other hash function in future for better performance, e.g. fnv hash.
myhash(void * buf,sal_Int32 buf_len)2143 inline sal_Int32 myhash(void * buf, sal_Int32 buf_len)
2144 {
2145 	return rtl_str_hashCode_WithLength( reinterpret_cast<const sal_Char *>(buf), buf_len);
2146 }
2147 
UpdateHashKey()2148 inline void SfxItemSet::UpdateHashKey()
2149 {
2150 	_aHashKey= myhash(_aItems,TotalCount()* sizeof(_aItems[0]));
2151 
2152 	//always treat '0' as invalidate hash key, not using addtional bool data field for saving space.
2153 	if (!IsValidateHashKey() )
2154 	{
2155 		_aHashKey = 1;
2156 	}
2157 }
2158 
QuickCompare(SfxItemSet & rCmp)2159 sal_Bool SfxItemSet::QuickCompare( SfxItemSet & rCmp)
2160 {
2161 	if ( _pParent != rCmp._pParent ||
2162 		 _pPool != rCmp._pPool ||
2163 		 Count() != rCmp.Count() )
2164 		return sal_False;
2165 
2166 	if ((0==Count())&&(0==rCmp.Count()))
2167 		return sal_True;
2168 
2169 	if (!IsValidateHashKey())
2170 	{
2171 		UpdateHashKey();
2172 	}
2173 	if (!rCmp.IsValidateHashKey())
2174 	{
2175 		rCmp.UpdateHashKey();
2176 	}
2177 
2178 	//improved performance here, in most cases, the hashkey is not equal.
2179 	if (GetHashKey() != rCmp.GetHashKey())
2180 		return sal_False;
2181 
2182 	if ( 0 == memcmp( _aItems, rCmp._aItems,  TotalCount() * sizeof(_aItems[0]) ) )
2183 		return sal_True;
2184 	else
2185 		return sal_False;
2186 }
2187 //end: i120575
2188