svx/source/unodraw/unonrule.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unonrule.cxx,v $
  10  * $Revision: 1.26 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #define PROPERTY_NONE 0
  35
  36 #include <com/sun/star/text/HoriOrientation.hpp>
  37 #include <com/sun/star/lang/XUnoTunnel.hpp>
  38 #include <com/sun/star/awt/XBitmap.hpp>
  39 #include <com/sun/star/beans/PropertyValue.hpp>
  40 #include <com/sun/star/lang/XServiceInfo.hpp>
  41 #include <com/sun/star/util/XCloneable.hpp>
  42
  43 #include <cppuhelper/implbase1.hxx>
  44 #include <cppuhelper/implbase5.hxx>
  45
  46 #include <svtools/itempool.hxx>
  47 #include <goodies/grfmgr.hxx>
  48
  49 #include <vcl/svapp.hxx>
  50 #include <vos/mutex.hxx>
  51 #include <vcl/graph.hxx>
  52
  53 #include <comphelper/servicehelper.hxx>
  54 #include <toolkit/unohlp.hxx>
  55 #include <rtl/uuid.h>
  56 #include <rtl/memory.h>
  57
  58 #include <svx/brshitem.hxx>
  59 #include <svx/unoprnms.hxx>
  60 #include <svx/numitem.hxx>
  61 #include <svx/eeitem.hxx>
  62 #include <svx/unotext.hxx>
  63 #include <svx/svdmodel.hxx>
  64 #include <svx/numitem.hxx>
  65 #include "unofdesc.hxx"
  66 #include "unonrule.hxx"
  67 #include "unoapi.hxx"
  68
  69 using ::rtl::OUString;
  70 using ::com::sun::star::util::XCloneable;
  71 using ::com::sun::star::ucb::XAnyCompare;
  72
  73
  74 using namespace ::vos;
  75 using namespace ::std;
  76 using namespace ::com::sun::star;
  77 using namespace ::com::sun::star::uno;
  78 using namespace ::com::sun::star::lang;
  79 using namespace ::com::sun::star::container;
  80
  81 const SvxAdjust aUnoToSvxAdjust[] =
  82 {
  83     SVX_ADJUST_LEFT,
  84     SVX_ADJUST_RIGHT,
  85     SVX_ADJUST_CENTER,
  86     SVX_ADJUST_LEFT,
  87     SVX_ADJUST_LEFT,
  88     SVX_ADJUST_LEFT,
  89     SVX_ADJUST_BLOCK
  90 };
  91
  92 const unsigned short aSvxToUnoAdjust[] =
  93 {
  94     text::HoriOrientation::LEFT,
  95     text::HoriOrientation::RIGHT,
  96     text::HoriOrientation::FULL,
  97     text::HoriOrientation::CENTER,
  98     text::HoriOrientation::FULL,
  99     text::HoriOrientation::LEFT
 100 };
 101
 102 SvxAdjust ConvertUnoAdjust( unsigned short nAdjust )
 103 {
 104     DBG_ASSERT( nAdjust <= 7, "Enum hat sich geaendert! [CL]" );
 105     return aUnoToSvxAdjust[nAdjust];
 106 }
 107
 108 unsigned short ConvertUnoAdjust( SvxAdjust eAdjust )
 109 {
 110     DBG_ASSERT( eAdjust <= 6, "Enum hat sich geaendert! [CL]" );
 111     return aSvxToUnoAdjust[eAdjust];
 112 }
 113
 114
 115
 116 /******************************************************************
 117  * SvxUnoNumberingRules
 118  ******************************************************************/
 119
 120 class SvxUnoNumberingRules : public ::cppu::WeakAggImplHelper5< XIndexReplace, XAnyCompare, XUnoTunnel, XCloneable, XServiceInfo >
 121 {
 122 private:
 123     SvxNumRule maRule;
 124 public:
 125     SvxUnoNumberingRules( const SvxNumRule& rRule ) throw();
 126     virtual ~SvxUnoNumberingRules() throw();
 127
 128     UNO3_GETIMPLEMENTATION_DECL( SvxUnoNumberingRules )
 129
 130     //XIndexReplace
 131     virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) throw(IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
 132
 133     //XIndexAccess
 134     virtual sal_Int32 SAL_CALL getCount() throw(RuntimeException) ;
 135     virtual Any SAL_CALL getByIndex( sal_Int32 Index ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
 136
 137     //XElementAccess
 138     virtual Type SAL_CALL getElementType() throw(RuntimeException);
 139     virtual sal_Bool SAL_CALL hasElements() throw(RuntimeException);
 140
 141     // XAnyCompare
 142     virtual sal_Int16 SAL_CALL compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException);
 143
 144     // XCloneable
 145     virtual Reference< XCloneable > SAL_CALL createClone(  ) throw (RuntimeException);
 146
 147     // XServiceInfo
 148     virtual OUString SAL_CALL getImplementationName(  ) throw(RuntimeException);
 149     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
 150     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw(RuntimeException);
 151
 152     // intern
 153     Sequence<beans::PropertyValue> getNumberingRuleByIndex( sal_Int32 nIndex) const throw();
 154     void setNumberingRuleByIndex( const Sequence< beans::PropertyValue >& rProperties, sal_Int32 nIndex) throw( RuntimeException, IllegalArgumentException );
 155
 156     static sal_Int16 Compare( const Any& rAny1, const Any& rAny2 );
 157
 158     const SvxNumRule& getNumRule() const { return maRule; }
 159 };
 160
 161 UNO3_GETIMPLEMENTATION_IMPL( SvxUnoNumberingRules );
 162
 163 SvxUnoNumberingRules::SvxUnoNumberingRules( const SvxNumRule& rRule ) throw()
 164 : maRule( rRule )
 165 {
 166 }
 167
 168 SvxUnoNumberingRules::~SvxUnoNumberingRules() throw()
 169 {
 170 }
 171
 172 //XIndexReplace
 173 void SAL_CALL SvxUnoNumberingRules::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
 174     throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 175 {
 176     OGuard aGuard( Application::GetSolarMutex() );
 177
 178     if( Index < 0 || Index >= maRule.GetLevelCount() )
 179         throw IndexOutOfBoundsException();
 180
 181     Sequence< beans::PropertyValue > aSeq;
 182
 183     if( !( Element >>= aSeq) )
 184         throw IllegalArgumentException();
 185     setNumberingRuleByIndex( aSeq, Index );
 186 }
 187
 188 // XIndexAccess
 189 sal_Int32 SAL_CALL SvxUnoNumberingRules::getCount() throw( RuntimeException )
 190 {
 191     OGuard aGuard( Application::GetSolarMutex() );
 192
 193     return maRule.GetLevelCount();
 194 }
 195
 196 Any SAL_CALL SvxUnoNumberingRules::getByIndex( sal_Int32 Index )
 197     throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 198 {
 199     OGuard aGuard( Application::GetSolarMutex() );
 200
 201     if( Index < 0 || Index >= maRule.GetLevelCount() )
 202         throw IndexOutOfBoundsException();
 203
 204     return Any( getNumberingRuleByIndex(Index) );
 205 }
 206
 207 //XElementAccess
 208 Type SAL_CALL SvxUnoNumberingRules::getElementType()
 209     throw( RuntimeException )
 210 {
 211     return ::getCppuType(( const Sequence< beans::PropertyValue >*)0);
 212 }
 213
 214 sal_Bool SAL_CALL SvxUnoNumberingRules::hasElements() throw( RuntimeException )
 215 {
 216     return sal_True;
 217 }
 218
 219 // XAnyCompare
 220 sal_Int16 SAL_CALL SvxUnoNumberingRules::compare( const Any& rAny1, const Any& rAny2 ) throw(RuntimeException)
 221 {
 222     return SvxUnoNumberingRules::Compare( rAny1, rAny2 );
 223 }
 224
 225 // XCloneable
 226 Reference< XCloneable > SAL_CALL SvxUnoNumberingRules::createClone(  ) throw (RuntimeException)
 227 {
 228     return new SvxUnoNumberingRules(maRule);
 229 }
 230
 231 // XServiceInfo
 232 sal_Char pSvxUnoNumberingRulesService[sizeof("com.sun.star.text.NumberingRules")] = "com.sun.star.text.NumberingRules";
 233
 234 OUString SAL_CALL SvxUnoNumberingRules::getImplementationName(  ) throw(RuntimeException)
 235 {
 236     return OUString( RTL_CONSTASCII_USTRINGPARAM( "SvxUnoNumberingRules" ) );
 237 }
 238
 239 sal_Bool SAL_CALL SvxUnoNumberingRules::supportsService( const OUString& ServiceName ) throw(RuntimeException)
 240 {
 241     return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( pSvxUnoNumberingRulesService ) );
 242 }
 243
 244 Sequence< OUString > SAL_CALL SvxUnoNumberingRules::getSupportedServiceNames(  ) throw(RuntimeException)
 245 {
 246     OUString aService( RTL_CONSTASCII_USTRINGPARAM( pSvxUnoNumberingRulesService ) );
 247     Sequence< OUString > aSeq( &aService, 1 );
 248     return aSeq;
 249 }
 250
 251 Sequence<beans::PropertyValue> SvxUnoNumberingRules::getNumberingRuleByIndex( sal_Int32 nIndex) const throw()
 252 {
 253     //  NumberingRule aRule;
 254     const SvxNumberFormat& rFmt = maRule.GetLevel((sal_uInt16) nIndex);
 255     sal_uInt16 nIdx = 0;
 256
 257     const int nProps = 15;
 258     beans::PropertyValue* pArray = new beans::PropertyValue[nProps];
 259
 260     Any aVal;
 261     {
 262         aVal <<= rFmt.GetNumberingType();
 263         beans::PropertyValue aAlignProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_NUMBERINGTYPE)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 264         pArray[nIdx++] = aAlignProp;
 265     }
 266
 267     {
 268         SvxAdjust eAdj = rFmt.GetNumAdjust();
 269         aVal <<= ConvertUnoAdjust(eAdj);
 270         pArray[nIdx++] = beans::PropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_ADJUST)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 271     }
 272
 273     {
 274         aVal <<= OUString(rFmt.GetPrefix());
 275         beans::PropertyValue aPrefixProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_PREFIX)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 276         pArray[nIdx++] = aPrefixProp;
 277     }
 278
 279     {
 280         aVal <<= OUString(rFmt.GetSuffix());
 281         beans::PropertyValue aSuffixProp( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_SUFFIX)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 282         pArray[nIdx++] = aSuffixProp;
 283     }
 284
 285     {
 286         sal_Unicode nCode = rFmt.GetBulletChar();
 287         OUString aStr( &nCode, 1 );
 288         aVal <<= aStr;
 289         beans::PropertyValue aBulletProp( OUString(RTL_CONSTASCII_USTRINGPARAM("BulletChar")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 290         pArray[nIdx++] = aBulletProp;
 291     }
 292
 293     if( rFmt.GetBulletFont() )
 294     {
 295         awt::FontDescriptor aDesc;
 296         SvxUnoFontDescriptor::ConvertFromFont( *rFmt.GetBulletFont(), aDesc );
 297         aVal.setValue(&aDesc, ::getCppuType((const awt::FontDescriptor*)0));
 298         pArray[nIdx++] = beans::PropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_FONT)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 299     }
 300
 301     {
 302         const SvxBrushItem* pBrush = rFmt.GetBrush();
 303         if(pBrush && pBrush->GetGraphicObject())
 304         {
 305             const GraphicObject* pGrafObj = pBrush->GetGraphicObject();
 306             OUString aURL( RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX));
 307             aURL += OUString::createFromAscii( pGrafObj->GetUniqueID().GetBuffer() );
 308
 309             aVal <<= aURL;
 310             const beans::PropertyValue aGraphicProp( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 311             pArray[nIdx++] = aGraphicProp;
 312         }
 313     }
 314
 315     {
 316         const Size aSize( rFmt.GetGraphicSize() );
 317         const awt::Size aUnoSize( aSize.Width(), aSize.Height() );
 318         aVal <<= aUnoSize;
 319         const beans::PropertyValue aGraphicSizeProp(OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicSize")), -1, aVal, beans::PropertyState_DIRECT_VALUE );
 320         pArray[nIdx++] = aGraphicSizeProp;
 321     }
 322
 323     aVal <<= (sal_Int16)rFmt.GetStart();
 324     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_START_WITH)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 325
 326     aVal <<= (sal_Int32)rFmt.GetAbsLSpace();
 327     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_LEFT_MARGIN)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 328
 329     aVal <<= (sal_Int32)rFmt.GetFirstLineOffset();
 330     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_FIRST_LINE_OFFSET)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 331
 332     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("SymbolTextDistance")), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 333
 334     aVal <<= (sal_Int32)rFmt.GetBulletColor().GetColor();
 335     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_COLOR)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 336
 337     aVal <<= (sal_Int16)rFmt.GetBulletRelSize();
 338     pArray[nIdx++] = beans::PropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_NRULE_BULLET_RELSIZE)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
 339
 340     DBG_ASSERT( nIdx <= nProps, "FixMe: Array uebergelaufen!!!! [CL]" );
 341     Sequence< beans::PropertyValue> aSeq(pArray, nIdx);
 342
 343     delete [] pArray;
 344     return aSeq;
 345 }
 346
 347 void SvxUnoNumberingRules::setNumberingRuleByIndex(     const Sequence< beans::PropertyValue >& rProperties, sal_Int32 nIndex)
 348     throw( RuntimeException, IllegalArgumentException )
 349 {
 350     SvxNumberFormat aFmt(maRule.GetLevel( (sal_uInt16)nIndex ));
 351     const beans::PropertyValue* pPropArray = rProperties.getConstArray();
 352     for(int i = 0; i < rProperties.getLength(); i++)
 353     {
 354         const beans::PropertyValue& rProp = pPropArray[i];
 355         const OUString& rPropName = rProp.Name;
 356         const Any& aVal = rProp.Value;
 357
 358         if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_NUMBERINGTYPE)))
 359         {
 360             sal_Int16 nSet = sal_Int16();
 361             aVal >>= nSet;
 362
 363             switch(nSet)
 364             {
 365             case SVX_NUM_BITMAP:
 366             case SVX_NUM_CHAR_SPECIAL:
 367             case SVX_NUM_ROMAN_UPPER:
 368             case SVX_NUM_ROMAN_LOWER:
 369             case SVX_NUM_CHARS_UPPER_LETTER:
 370             case SVX_NUM_CHARS_LOWER_LETTER:
 371             case SVX_NUM_ARABIC:
 372             case SVX_NUM_NUMBER_NONE:
 373             case SVX_NUM_CHARS_UPPER_LETTER_N:
 374             case SVX_NUM_CHARS_LOWER_LETTER_N:
 375                 aFmt.SetNumberingType(nSet);
 376                 continue;
 377             }
 378         }
 379         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_PREFIX)))
 380         {
 381             OUString aPrefix;
 382             if( aVal >>= aPrefix )
 383             {
 384                 aFmt.SetPrefix(aPrefix);
 385                 continue;
 386             }
 387         }
 388         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_SUFFIX)))
 389         {
 390             OUString aSuffix;
 391             if( aVal >>= aSuffix )
 392             {
 393                 aFmt.SetSuffix(aSuffix);
 394                 continue;
 395             }
 396         }
 397         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLETID)))
 398         {
 399             sal_Int16 nSet = sal_Int16();
 400             if( aVal >>= nSet )
 401             {
 402                 if(nSet < 0x100)
 403                 {
 404                     aFmt.SetBulletChar(nSet);
 405                     continue;
 406                 }
 407             }
 408         }
 409         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("BulletChar")))
 410         {
 411             OUString aStr;
 412             if( aVal >>= aStr )
 413             {
 414                 if(aStr.getLength())
 415                 {
 416                     aFmt.SetBulletChar(aStr[0]);
 417                 }
 418                 else
 419                 {
 420                     aFmt.SetBulletChar(0);
 421                 }
 422                 continue;
 423             }
 424         }
 425         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_ADJUST)))
 426         {
 427             sal_Int16 nAdjust = sal_Int16();
 428             if( aVal >>= nAdjust )
 429             {
 430                 aFmt.SetNumAdjust(ConvertUnoAdjust( (unsigned short)nAdjust ));
 431                 continue;
 432             }
 433         }
 434         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_FONT)))
 435         {
 436             awt::FontDescriptor aDesc;
 437             if( aVal >>= aDesc )
 438             {
 439                 Font aFont;
 440                 SvxUnoFontDescriptor::ConvertToFont( aDesc, aFont );
 441                 aFmt.SetBulletFont(&aFont);
 442                 continue;
 443             }
 444         }
 445         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("Graphic")))
 446         {
 447             Reference< awt::XBitmap > xBmp;
 448             if( aVal >>= xBmp )
 449             {
 450                 Graphic aGraf( VCLUnoHelper::GetBitmap( xBmp ) );
 451                 SvxBrushItem aBrushItem(aGraf, GPOS_AREA, SID_ATTR_BRUSH);
 452                 aFmt.SetGraphicBrush( &aBrushItem );
 453                 continue;
 454             }
 455         }
 456         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("GraphicURL")))
 457         {
 458             OUString aURL;
 459             if( aVal >>= aURL )
 460             {
 461                 GraphicObject aGrafObj( CreateGraphicObjectFromURL( aURL ) );
 462                 SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
 463                 aFmt.SetGraphicBrush( &aBrushItem );
 464                 continue;
 465             }
 466         }
 467         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("GraphicSize")))
 468         {
 469             awt::Size aUnoSize;
 470             if( aVal >>= aUnoSize )
 471             {
 472                 aFmt.SetGraphicSize( Size( aUnoSize.Width, aUnoSize.Height ) );
 473                 continue;
 474             }
 475         }
 476         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_START_WITH)))
 477         {
 478             sal_Int16 nStart = sal_Int16();
 479             if( aVal >>= nStart )
 480             {
 481                 aFmt.SetStart( nStart );
 482                 continue;
 483             }
 484         }
 485         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_LEFT_MARGIN)))
 486         {
 487             sal_Int32 nMargin = 0;
 488             if( aVal >>= nMargin )
 489             {
 490                 aFmt.SetAbsLSpace((sal_uInt16)nMargin);
 491                 continue;
 492             }
 493         }
 494         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_FIRST_LINE_OFFSET)))
 495         {
 496             sal_Int32 nMargin = 0;
 497             if( aVal >>= nMargin )
 498             {
 499                 aFmt.SetFirstLineOffset((sal_uInt16)nMargin);
 500                 continue;
 501             }
 502         }
 503         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("SymbolTextDistance")))
 504         {
 505             sal_Int32 nTextDistance = 0;
 506             if( aVal >>= nTextDistance )
 507             {
 508                 aFmt.SetCharTextDistance((sal_uInt16)nTextDistance);
 509                 continue;
 510             }
 511         }
 512         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_COLOR)))
 513         {
 514             sal_Int32 nColor = 0;
 515             if( aVal >>= nColor )
 516             {
 517                 aFmt.SetBulletColor( (Color) nColor );
 518                 continue;
 519             }
 520         }
 521         else if(rPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_NAME_NRULE_BULLET_RELSIZE)))
 522         {
 523             sal_Int16 nSize = sal_Int16();
 524             if( aVal >>= nSize )
 525             {
 526                 aFmt.SetBulletRelSize( (short)nSize );
 527                 continue;
 528             }
 529         }
 530         else
 531         {
 532             continue;
 533         }
 534
 535         throw IllegalArgumentException();
 536     }
 537
 538     // check that we always have a brush item for bitmap numbering
 539     if( aFmt.GetNumberingType() == SVX_NUM_BITMAP )
 540     {
 541         if( NULL == aFmt.GetBrush() )
 542         {
 543             GraphicObject aGrafObj;
 544             SvxBrushItem aBrushItem( aGrafObj, GPOS_AREA, SID_ATTR_BRUSH );
 545             aFmt.SetGraphicBrush( &aBrushItem );
 546         }
 547     }
 548     maRule.SetLevel( (sal_uInt16)nIndex, aFmt );
 549 }
 550
 551 ///////////////////////////////////////////////////////////////////////
 552
 553 const SvxNumRule& SvxGetNumRule( Reference< XIndexReplace > xRule ) throw( IllegalArgumentException )
 554 {
 555     SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
 556     if( pRule == NULL )
 557         throw IllegalArgumentException();
 558
 559     return pRule->getNumRule();
 560 }
 561
 562 bool SvxGetNumRule( Reference< XIndexReplace > xRule, SvxNumRule& rNumRule )
 563 {
 564     SvxUnoNumberingRules* pRule = SvxUnoNumberingRules::getImplementation( xRule );
 565     if( pRule )
 566     {
 567         rNumRule = pRule->getNumRule();
 568     }
 569     else if( xRule.is() )
 570     {
 571         try
 572         {
 573             pRule = new SvxUnoNumberingRules( rNumRule );
 574
 575             Reference< XIndexReplace > xDestRule( pRule );
 576
 577             const sal_Int32 nCount = min( xRule->getCount(), xDestRule->getCount() );
 578             sal_Int32 nLevel;
 579             for( nLevel = 0; nLevel < nCount; nLevel++ )
 580             {
 581                 xDestRule->replaceByIndex( nLevel, xRule->getByIndex( nLevel ) );
 582             }
 583
 584             rNumRule = pRule->getNumRule();
 585         }
 586         catch( Exception& )
 587         {
 588             return false;
 589         }
 590     }
 591     else
 592     {
 593         return false;
 594     }
 595
 596     return true;
 597 }
 598
 599 ///////////////////////////////////////////////////////////////////////
 600
 601 Reference< XIndexReplace > SvxCreateNumRule( const SvxNumRule* pRule ) throw()
 602 {
 603     DBG_ASSERT( pRule, "No default SvxNumRule!" );
 604     if( pRule )
 605     {
 606         return new SvxUnoNumberingRules( *pRule );
 607     }
 608     else
 609     {
 610         SvxNumRule aDefaultRule( NUM_BULLET_REL_SIZE|NUM_BULLET_COLOR|NUM_CHAR_TEXT_DISTANCE, 10 , FALSE);
 611         return new SvxUnoNumberingRules( aDefaultRule );
 612     }
 613 }
 614
 615 ///////////////////////////////////////////////////////////////////////
 616
 617 Reference< XIndexReplace > SvxCreateNumRule( SdrModel* pModel ) throw()
 618 {
 619     SvxNumRule* pDefaultRule = NULL;
 620     if( pModel )
 621     {
 622         SvxNumBulletItem* pItem = (SvxNumBulletItem*) pModel->GetItemPool().GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
 623         if( pItem )
 624         {
 625             pDefaultRule = pItem->GetNumRule();
 626         }
 627     }
 628
 629     if( pDefaultRule )
 630     {
 631         return SvxCreateNumRule( pDefaultRule );
 632     }
 633     else
 634     {
 635         SvxNumRule aTempRule( 0, 10, false );
 636         return SvxCreateNumRule( &aTempRule );
 637     }
 638 }
 639
 640 ///////////////////////////////////////////////////////////////////////
 641
 642 class SvxUnoNumberingRulesCompare : public ::cppu::WeakAggImplHelper1< XAnyCompare >
 643 {
 644 public:
 645     virtual sal_Int16 SAL_CALL compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException);
 646 };
 647
 648 sal_Int16 SAL_CALL SvxUnoNumberingRulesCompare::compare( const Any& Any1, const Any& Any2 ) throw(RuntimeException)
 649 {
 650     return SvxUnoNumberingRules::Compare( Any1, Any2 );
 651 }
 652
 653 sal_Int16 SvxUnoNumberingRules::Compare( const Any& Any1, const Any& Any2 )
 654 {
 655     Reference< XIndexReplace > x1( Any1, UNO_QUERY ), x2( Any2, UNO_QUERY );
 656     if( x1.is() && x2.is() )
 657     {
 658         if( x1.get() == x2.get() )
 659             return 0;
 660
 661         SvxUnoNumberingRules* pRule1 = SvxUnoNumberingRules::getImplementation( x1 );
 662         if( pRule1 )
 663         {
 664             SvxUnoNumberingRules* pRule2 = SvxUnoNumberingRules::getImplementation( x2 );
 665             if( pRule2 )
 666             {
 667                 const SvxNumRule& rRule1 = pRule1->getNumRule();
 668                 const SvxNumRule& rRule2 = pRule2->getNumRule();
 669
 670                 const USHORT nLevelCount1 = rRule1.GetLevelCount();
 671                 const USHORT nLevelCount2 = rRule2.GetLevelCount();
 672
 673                 if( nLevelCount1 == 0 || nLevelCount2 == 0 )
 674                     return -1;
 675
 676                 for( USHORT i = 0; (i < nLevelCount1) && (i < nLevelCount2); i++ )
 677                 {
 678                     if( rRule1.GetLevel(i) != rRule2.GetLevel(i) )
 679                         return -1;
 680                 }
 681                 return  0;
 682             }
 683         }
 684     }
 685
 686     return -1;
 687 }
 688
 689 Reference< XAnyCompare > SvxCreateNumRuleCompare() throw()
 690 {
 691     return new SvxUnoNumberingRulesCompare();
 692 }