editeng/source/uno/unonrule.cxx

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