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