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