xref: /aoo42x/main/editeng/source/uno/unonrule.cxx (revision 4d7c9de0)
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_editeng.hxx"
26 
27 #define PROPERTY_NONE 0
28 
29 #include <com/sun/star/text/HoriOrientation.hpp>
30 #include <com/sun/star/awt/XBitmap.hpp>
31 
32 #include <vcl/svapp.hxx>
33 #include <vos/mutex.hxx>
34 #include <vcl/graph.hxx>
35 #include <svtools/grfmgr.hxx>
36 #include <toolkit/unohlp.hxx>
37 #include <rtl/uuid.h>
38 #include <rtl/memory.h>
39 
40 #include <editeng/brshitem.hxx>
41 #include <editeng/unoprnms.hxx>
42 #include <editeng/numitem.hxx>
43 #include <editeng/eeitem.hxx>
44 #include <editeng/unotext.hxx>
45 #include <editeng/numitem.hxx>
46 #include <editeng/unofdesc.hxx>
47 #include <editeng/unonrule.hxx>
48 #include <editeng/editids.hrc>
49 
50 using ::rtl::OUString;
51 using ::com::sun::star::util::XCloneable;
52 using ::com::sun::star::ucb::XAnyCompare;
53 
54 
55 using namespace ::vos;
56 using namespace ::std;
57 using namespace ::com::sun::star;
58 using namespace ::com::sun::star::uno;
59 using namespace ::com::sun::star::lang;
60 using namespace ::com::sun::star::container;
61 
62 const SvxAdjust aUnoToSvxAdjust[] =
63 {
64 	SVX_ADJUST_LEFT,
65 	SVX_ADJUST_RIGHT,
66 	SVX_ADJUST_CENTER,
67 	SVX_ADJUST_LEFT,
68 	SVX_ADJUST_LEFT,
69 	SVX_ADJUST_LEFT,
70 	SVX_ADJUST_BLOCK
71 };
72 
73 const unsigned short aSvxToUnoAdjust[] =
74 {
75 	text::HoriOrientation::LEFT,
76 	text::HoriOrientation::RIGHT,
77 	text::HoriOrientation::FULL,
78 	text::HoriOrientation::CENTER,
79 	text::HoriOrientation::FULL,
80 	text::HoriOrientation::LEFT
81 };
82 
83 SvxAdjust ConvertUnoAdjust( unsigned short nAdjust )
84 {
85 	DBG_ASSERT( nAdjust <= 7, "Enum hat sich geaendert! [CL]" );
86 	return aUnoToSvxAdjust[nAdjust];
87 }
88 
89 unsigned short ConvertUnoAdjust( SvxAdjust eAdjust )
90 {
91 	DBG_ASSERT( eAdjust <= 6, "Enum hat sich geaendert! [CL]" );
92 	return aSvxToUnoAdjust[eAdjust];
93 }
94 
95 /******************************************************************
96  * SvxUnoNumberingRules
97  ******************************************************************/
98 
99 UNO3_GETIMPLEMENTATION_IMPL( SvxUnoNumberingRules );
100 
101 SvxUnoNumberingRules::SvxUnoNumberingRules( const SvxNumRule& rRule ) throw()
102 : maRule( rRule )
103 {
104 }
105 
106 SvxUnoNumberingRules::~SvxUnoNumberingRules() throw()
107 {
108 }
109 
110 //XIndexReplace
111 void SAL_CALL SvxUnoNumberingRules::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
112 	throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
113 {
114 	OGuard aGuard( Application::GetSolarMutex() );
115 
116 	if( Index < 0 || Index >= maRule.GetLevelCount() )
117 		throw IndexOutOfBoundsException();
118 
119 	Sequence< beans::PropertyValue > aSeq;
120 
121 	if( !( Element >>= aSeq) )
122 		throw IllegalArgumentException();
123 	setNumberingRuleByIndex( aSeq, Index );
124 }
125 
126 // XIndexAccess
127 sal_Int32 SAL_CALL SvxUnoNumberingRules::getCount() throw( RuntimeException )
128 {
129 	OGuard aGuard( Application::GetSolarMutex() );
130 
131 	return maRule.GetLevelCount();
132 }
133 
134 Any SAL_CALL SvxUnoNumberingRules::getByIndex( sal_Int32 Index )
135 	throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
136 {
137 	OGuard aGuard( Application::GetSolarMutex() );
138 
139 	if( Index < 0 || Index >= maRule.GetLevelCount() )
140 		throw IndexOutOfBoundsException();
141 
142 	return Any( getNumberingRuleByIndex(Index) );
143 }
144 
145 //XElementAccess
146 Type SAL_CALL SvxUnoNumberingRules::getElementType()
147 	throw( RuntimeException )
148 {
149 	return ::getCppuType(( const Sequence< beans::PropertyValue >*)0);
150 }
151 
152 sal_Bool SAL_CALL SvxUnoNumberingRules::hasElements() throw( RuntimeException )
153 {
154 	return sal_True;
155 }
156 
157 // XAnyCompare
158 sal_Int16 SAL_CALL SvxUnoNumberingRules::compare( const Any& rAny1, const Any& rAny2 ) throw(RuntimeException)
159 {
160     return SvxUnoNumberingRules::Compare( rAny1, rAny2 );
161 }
162 
163 // XCloneable
164 Reference< XCloneable > SAL_CALL SvxUnoNumberingRules::createClone(  ) throw (RuntimeException)
165 {
166     return new SvxUnoNumberingRules(maRule);
167 }
168 
169 // XServiceInfo
170 sal_Char pSvxUnoNumberingRulesService[sizeof("com.sun.star.text.NumberingRules")] = "com.sun.star.text.NumberingRules";
171 
172 OUString SAL_CALL SvxUnoNumberingRules::getImplementationName(  ) throw(RuntimeException)
173 {
174 	return OUString( RTL_CONSTASCII_USTRINGPARAM( "SvxUnoNumberingRules" ) );
175 }
176 
177 sal_Bool SAL_CALL SvxUnoNumberingRules::supportsService( const OUString& ServiceName ) throw(RuntimeException)
178 {
179 	return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( pSvxUnoNumberingRulesService ) );
180 }
181 
182 Sequence< OUString > SAL_CALL SvxUnoNumberingRules::getSupportedServiceNames(  ) throw(RuntimeException)
183 {
184 	OUString aService( RTL_CONSTASCII_USTRINGPARAM( pSvxUnoNumberingRulesService ) );
185 	Sequence< OUString > aSeq( &aService, 1 );
186 	return aSeq;
187 }
188 
189 Sequence<beans::PropertyValue> SvxUnoNumberingRules::getNumberingRuleByIndex( sal_Int32 nIndex) const throw()
190 {
191 	//	NumberingRule aRule;
192 	const SvxNumberFormat& rFmt = maRule.GetLevel((sal_uInt16) nIndex);
193 	sal_uInt16 nIdx = 0;
194 
195 	const int nProps = 15;
196 	beans::PropertyValue* pArray = new beans::PropertyValue[nProps];
197 
198 	Any aVal;
199 	{
200 		aVal <<= rFmt.GetNumberingType();
201 		beans::PropertyValue aAlignProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_NUMBERINGTYPE)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
202 		pArray[nIdx++] = aAlignProp;
203 	}
204 
205 	{
206 		SvxAdjust eAdj = rFmt.GetNumAdjust();
207 		aVal <<= ConvertUnoAdjust(eAdj);
208 		pArray[nIdx++] = beans::PropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_ADJUST)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
209 	}
210 
211 	{
212 		aVal <<= OUString(rFmt.GetPrefix());
213 		beans::PropertyValue aPrefixProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_PREFIX)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
214 		pArray[nIdx++] = aPrefixProp;
215 	}
216 
217 	{
218 		aVal <<= OUString(rFmt.GetSuffix());
219 		beans::PropertyValue aSuffixProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_SUFFIX)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
220 		pArray[nIdx++] = aSuffixProp;
221 	}
222 
223 	{
224 		if(SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType())
225 		{
226 		sal_Unicode nCode = rFmt.GetBulletChar();
227 		OUString aStr( &nCode, 1 );
228 		aVal <<= aStr;
229 		beans::PropertyValue aBulletProp( OUString(RTL_CONSTASCII_USTRINGPARAM("BulletChar")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
230 		pArray[nIdx++] = aBulletProp;
231 		}
232 	}
233 
234 	if( rFmt.GetBulletFont() )
235 	{
236 		awt::FontDescriptor aDesc;
237 		SvxUnoFontDescriptor::ConvertFromFont( *rFmt.GetBulletFont(), aDesc );
238 		aVal.setValue(&aDesc, ::getCppuType((const awt::FontDescriptor*)0));
239 		pArray[nIdx++] = beans::PropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_FONT)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
240 	}
241 
242 	{
243 		const SvxBrushItem* pBrush = rFmt.GetBrush();
244 		if(pBrush && pBrush->GetGraphicObject())
245 		{
246 			const GraphicObject* pGrafObj = pBrush->GetGraphicObject();
247 			OUString aURL( RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX));
248 			aURL += OUString::createFromAscii( pGrafObj->GetUniqueID().GetBuffer() );
249 
250 			aVal <<= aURL;
251 			const beans::PropertyValue aGraphicProp( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
252 			pArray[nIdx++] = aGraphicProp;
253 		}
254 	}
255 
256 	{
257 		const Size aSize( rFmt.GetGraphicSize() );
258 		const awt::Size aUnoSize( aSize.Width(), aSize.Height() );
259 		aVal <<= aUnoSize;
260 		const beans::PropertyValue aGraphicSizeProp(OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicSize")), -1, aVal, beans::PropertyState_DIRECT_VALUE );
261 		pArray[nIdx++] = aGraphicSizeProp;
262 	}
263 
264 	aVal <<= (sal_Int16)rFmt.GetStart();
265 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_START_WITH)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
266 
267 	aVal <<= (sal_Int32)rFmt.GetAbsLSpace();
268 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_LEFT_MARGIN)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
269 
270 	aVal <<= (sal_Int32)rFmt.GetFirstLineOffset();
271 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_FIRST_LINE_OFFSET)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
272 
273 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("SymbolTextDistance")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
274 
275 	aVal <<= (sal_Int32)rFmt.GetBulletColor().GetColor();
276 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_COLOR)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
277 
278 	aVal <<= (sal_Int16)rFmt.GetBulletRelSize();
279 	pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_RELSIZE)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
280 
281 	DBG_ASSERT( nIdx <= nProps, "FixMe: Array uebergelaufen!!!! [CL]" );
282 	Sequence< beans::PropertyValue> aSeq(pArray, nIdx);
283 
284 	delete [] pArray;
285 	return aSeq;
286 }
287 
288 void SvxUnoNumberingRules::setNumberingRuleByIndex(	const Sequence< beans::PropertyValue >& rProperties, sal_Int32 nIndex)
289 	throw( RuntimeException, IllegalArgumentException )
290 {
291 	SvxNumberFormat aFmt(maRule.GetLevel( (sal_uInt16)nIndex ));
292 	const beans::PropertyValue* pPropArray = rProperties.getConstArray();
293 	for(int i = 0; i < rProperties.getLength(); i++)
294 	{
295 		const beans::PropertyValue& rProp = pPropArray[i];
296 		const OUString& rPropName = rProp.Name;
297 		const Any& aVal = rProp.Value;
298 
299 		if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_NUMBERINGTYPE)))
300 		{
301 			sal_Int16 nSet = sal_Int16();
302 			aVal >>= nSet;
303 
304 			// There is no reason to limit numbering types.
305 			if ( nSet>=0 )
306 			{
307 				aFmt.SetNumberingType(nSet);
308 				continue;
309 			}
310 		}
311 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_PREFIX)))
312 		{
313 			OUString aPrefix;
314 			if( aVal >>= aPrefix )
315 			{
316 				aFmt.SetPrefix(aPrefix);
317 				continue;
318 			}
319 		}
320 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_SUFFIX)))
321 		{
322 			OUString aSuffix;
323 			if( aVal >>= aSuffix )
324 			{
325 				aFmt.SetSuffix(aSuffix);
326 				continue;
327 			}
328 		}
329 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLETID)))
330 		{
331 			sal_Int16 nSet = sal_Int16();
332 			if( aVal >>= nSet )
333 			{
334 				if(nSet < 0x100)
335 				{
336 					aFmt.SetBulletChar(nSet);
337 					continue;
338 				}
339 			}
340 		}
341 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("BulletChar")))
342 		{
343 			OUString aStr;
344 			if( aVal >>= aStr )
345 			{
346 				if(aStr.getLength())
347 				{
348 					aFmt.SetBulletChar(aStr[0]);
349 				}
350 				else
351 				{
352 					aFmt.SetBulletChar(0);
353 				}
354 				continue;
355 			}
356 		}
357 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_ADJUST)))
358 		{
359 			sal_Int16 nAdjust = sal_Int16();
360 			if( aVal >>= nAdjust )
361 			{
362 				aFmt.SetNumAdjust(ConvertUnoAdjust( (unsigned short)nAdjust ));
363 				continue;
364 			}
365 		}
366 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_FONT)))
367 		{
368 			awt::FontDescriptor aDesc;
369 			if( aVal >>= aDesc )
370 			{
371 				Font aFont;
372 				SvxUnoFontDescriptor::ConvertToFont( aDesc, aFont );
373 				aFmt.SetBulletFont(&aFont);
374 				continue;
375 			}
376 		}
377 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("Graphic")))
378 		{
379 			Reference< awt::XBitmap > xBmp;
380 			if( aVal >>= xBmp )
381 			{
382 				Graphic aGraf( VCLUnoHelper::GetBitmap( xBmp ) );
383                 SvxBrushItem aBrushItem(aGraf, GPOS_AREA, SID_ATTR_BRUSH);
384 				aFmt.SetGraphicBrush( &aBrushItem );
385 				continue;
386 			}
387 		}
388 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("GraphicURL")))
389 		{
390 			OUString aURL;
391 			if( aVal >>= aURL )
392 			{
393 				GraphicObject aGrafObj( GraphicObject::CreateGraphicObjectFromURL( aURL ) );
394                 SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
395 				aFmt.SetGraphicBrush( &aBrushItem );
396 				continue;
397 			}
398 		}
399 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("GraphicSize")))
400 		{
401 			awt::Size aUnoSize;
402 			if( aVal >>= aUnoSize )
403 			{
404 				aFmt.SetGraphicSize( Size( aUnoSize.Width, aUnoSize.Height ) );
405 				continue;
406 			}
407 		}
408 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_START_WITH)))
409 		{
410 			sal_Int16 nStart = sal_Int16();
411 			if( aVal >>= nStart )
412 			{
413 				aFmt.SetStart( nStart );
414 				continue;
415 			}
416 		}
417 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_LEFT_MARGIN)))
418 		{
419 			sal_Int32 nMargin = 0;
420 			if( aVal >>= nMargin )
421 			{
422 				aFmt.SetAbsLSpace((sal_uInt16)nMargin);
423 				continue;
424 			}
425 		}
426 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_FIRST_LINE_OFFSET)))
427 		{
428 			sal_Int32 nMargin = 0;
429 			if( aVal >>= nMargin )
430 			{
431 				aFmt.SetFirstLineOffset((sal_uInt16)nMargin);
432 				continue;
433 			}
434 		}
435 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("SymbolTextDistance")))
436 		{
437 			sal_Int32 nTextDistance = 0;
438 			if( aVal >>= nTextDistance )
439 			{
440 				aFmt.SetCharTextDistance((sal_uInt16)nTextDistance);
441 				continue;
442 			}
443 		}
444 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_COLOR)))
445 		{
446 			sal_Int32 nColor = 0;
447 			if( aVal >>= nColor )
448 			{
449 				aFmt.SetBulletColor( (Color) nColor );
450 				continue;
451 			}
452 		}
453 		else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_RELSIZE)))
454 		{
455 			sal_Int16 nSize = sal_Int16();
456 			if( aVal >>= nSize )
457 			{
458                 // [Bug 120650] the slide content corrupt when open in Aoo
459                 if ((nSize>250)||(nSize<=0))
460                 {
461                     nSize = 100;
462                 }
463 
464 				aFmt.SetBulletRelSize( (short)nSize );
465 				continue;
466 			}
467 		}
468 		else
469 		{
470 			continue;
471 		}
472 
473 		throw IllegalArgumentException();
474 	}
475 
476 	// check that we always have a brush item for bitmap numbering
477 	if( aFmt.GetNumberingType() == SVX_NUM_BITMAP )
478 	{
479 		if( NULL == aFmt.GetBrush() )
480 		{
481 			GraphicObject aGrafObj;
482             SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
483 			aFmt.SetGraphicBrush( &aBrushItem );
484 		}
485 	}
486 	maRule.SetLevel( (sal_uInt16)nIndex, aFmt );
487 }
488 
489 ///////////////////////////////////////////////////////////////////////
490 
491 const SvxNumRule& SvxGetNumRule( Reference< XIndexReplace > xRule ) throw( IllegalArgumentException )
492 {
493 	SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
494 	if( pRule == NULL )
495 		throw IllegalArgumentException();
496 
497 	return pRule->getNumRule();
498 }
499 
500 bool SvxGetNumRule( Reference< XIndexReplace > xRule, SvxNumRule& rNumRule )
501 {
502 	SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
503 	if( pRule )
504 	{
505 		rNumRule = pRule->getNumRule();
506 	}
507 	else if( xRule.is() )
508 	{
509 		try
510 		{
511 			pRule = new SvxUnoNumberingRules( rNumRule );
512 
513 			Reference< XIndexReplace > xDestRule( pRule );
514 
515 			const sal_Int32 nCount = min( xRule->getCount(), xDestRule->getCount() );
516 			sal_Int32 nLevel;
517 			for( nLevel = 0; nLevel < nCount; nLevel++ )
518 			{
519 				xDestRule->replaceByIndex( nLevel, xRule->getByIndex( nLevel ) );
520 			}
521 
522 			rNumRule = pRule->getNumRule();
523 		}
524 		catch( Exception& )
525 		{
526 			return false;
527 		}
528 	}
529 	else
530 	{
531 		return false;
532 	}
533 
534 	return true;
535 }
536 
537 ///////////////////////////////////////////////////////////////////////
538 com::sun::star::uno::Reference< com::sun::star::container::XIndexReplace > SvxCreateNumRule( const SvxNumRule* pRule ) throw()
539 {
540 	DBG_ASSERT( pRule, "No default SvxNumRule!" );
541 	if( pRule )
542 	{
543 		return new SvxUnoNumberingRules( *pRule );
544 	}
545 	else
546 	{
547 		SvxNumRule aDefaultRule( NUM_BULLET_REL_SIZE|NUM_BULLET_COLOR|NUM_CHAR_TEXT_DISTANCE, 10 , sal_False);
548 		return new SvxUnoNumberingRules( aDefaultRule );
549 	}
550 }
551 
552 
553 ///////////////////////////////////////////////////////////////////////
554 
555 class SvxUnoNumberingRulesCompare : public ::cppu::WeakAggImplHelper1< XAnyCompare >
556 {
557 public:
558     virtual sal_Int16 SAL_CALL compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException);
559 };
560 
561 sal_Int16 SAL_CALL SvxUnoNumberingRulesCompare::compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException)
562 {
563     return SvxUnoNumberingRules::Compare( Any1, Any2 );
564 }
565 
566 sal_Int16 SvxUnoNumberingRules::Compare( const Any& Any1, const Any& Any2 )
567 {
568 	Reference< XIndexReplace > x1( Any1, UNO_QUERY ), x2( Any2, UNO_QUERY );
569 	if( x1.is() && x2.is() )
570 	{
571 		if( x1.get() == x2.get() )
572 			return 0;
573 
574 		SvxUnoNumberingRules* pRule1 = SvxUnoNumberingRules::getImplementation( x1 );
575 		if( pRule1 )
576 		{
577 			SvxUnoNumberingRules* pRule2 = SvxUnoNumberingRules::getImplementation( x2 );
578 			if( pRule2 )
579 			{
580 				const SvxNumRule& rRule1 = pRule1->getNumRule();
581 				const SvxNumRule& rRule2 = pRule2->getNumRule();
582 
583 				const sal_uInt16 nLevelCount1 = rRule1.GetLevelCount();
584 				const sal_uInt16 nLevelCount2 = rRule2.GetLevelCount();
585 
586 				if( nLevelCount1 == 0 || nLevelCount2 == 0 )
587 					return -1;
588 
589 				for( sal_uInt16 i = 0; (i < nLevelCount1) && (i < nLevelCount2); i++ )
590 				{
591 					if( rRule1.GetLevel(i) != rRule2.GetLevel(i) )
592 						return -1;
593 				}
594 				return  0;
595 			}
596 		}
597 	}
598 
599 	return -1;
600 }
601 
602 Reference< XAnyCompare > SvxCreateNumRuleCompare() throw()
603 {
604 	return new SvxUnoNumberingRulesCompare();
605 }
606 
607 ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexReplace > SvxCreateNumRule() throw()
608 {
609 	SvxNumRule aTempRule( 0, 10, false );
610 	return SvxCreateNumRule( &aTempRule );
611 }
612