sd/source/core/stlfamily.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/lang/DisposedException.hpp>
  21 #include <com/sun/star/lang/IllegalAccessException.hpp>
  22 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  23 #include <cppuhelper/supportsservice.hxx>
  24
  25 #include <vcl/svapp.hxx>
  26
  27 #include <svl/style.hxx>
  28
  29 #include <svx/unoprov.hxx>
  30
  31 #include <strings.hrc>
  32 #include <stlfamily.hxx>
  33 #include <stlsheet.hxx>
  34 #include <sdresid.hxx>
  35 #include <drawdoc.hxx>
  36 #include <sdpage.hxx>
  37 #include <glob.hxx>
  38
  39 #include <map>
  40 #include <memory>
  41
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::lang;
  44 using namespace ::com::sun::star::container;
  45 using namespace ::com::sun::star::style;
  46 using namespace ::com::sun::star::beans;
  47
  48 typedef std::map< OUString, rtl::Reference< SdStyleSheet > > PresStyleMap;
  49
  50 struct SdStyleFamilyImpl
  51 {
  52     tools::WeakReference<SdPage> mxMasterPage;
  53     OUString maLayoutName;
  54
  55     PresStyleMap& getStyleSheets();
  56     rtl::Reference< SfxStyleSheetPool > mxPool;
  57
  58 private:
  59     PresStyleMap maStyleSheets;
  60 };
  61
  62 PresStyleMap& SdStyleFamilyImpl::getStyleSheets()
  63 {
  64     if( mxMasterPage.is() && (mxMasterPage->GetLayoutName() != maLayoutName) )
  65     {
  66         maLayoutName = mxMasterPage->GetLayoutName();
  67
  68         OUString aLayoutName( maLayoutName );
  69         const sal_Int32 nLen = aLayoutName.indexOf(SD_LT_SEPARATOR ) + 4;
  70         aLayoutName = aLayoutName.copy(0, nLen );
  71
  72         if( (maStyleSheets.empty()) || !(*maStyleSheets.begin()).second->GetName().startsWith( aLayoutName) )
  73         {
  74             maStyleSheets.clear();
  75
  76             // The iterator will return only style sheets of family master page
  77             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), SfxStyleFamily::Page);
  78             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
  79                                      pStyle = aSSSIterator->Next() )
  80             {
  81                 // we assume that we have only SdStyleSheets
  82                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
  83                 if (pSdStyle->GetName().startsWith(aLayoutName))
  84                 {
  85                     maStyleSheets[ pSdStyle->GetApiName() ].set( pSdStyle );
  86                 }
  87             }
  88         }
  89     }
  90
  91     return maStyleSheets;
  92 }
  93
  94 SdStyleFamily::SdStyleFamily( const rtl::Reference< SfxStyleSheetPool >& xPool, SfxStyleFamily nFamily )
  95 : mnFamily( nFamily )
  96 , mxPool( xPool )
  97 {
  98 }
  99
 100 SdStyleFamily::SdStyleFamily( const rtl::Reference< SfxStyleSheetPool >& xPool, const SdPage* pMasterPage )
 101 : mnFamily( SfxStyleFamily::Page )
 102 , mxPool( xPool )
 103 , mpImpl( new SdStyleFamilyImpl )
 104 {
 105     mpImpl->mxMasterPage.reset( const_cast< SdPage* >( pMasterPage ) );
 106     mpImpl->mxPool = xPool;
 107 }
 108
 109 SdStyleFamily::~SdStyleFamily()
 110 {
 111     DBG_ASSERT( !mxPool.is(), "SdStyleFamily::~SdStyleFamily(), dispose me first!" );
 112 }
 113
 114 void SdStyleFamily::throwIfDisposed() const
 115 {
 116     if( !mxPool.is() )
 117         throw DisposedException();
 118 }
 119
 120 SdStyleSheet* SdStyleFamily::GetValidNewSheet( const Any& rElement )
 121 {
 122     Reference< XStyle > xStyle( rElement, UNO_QUERY );
 123     SdStyleSheet* pStyle = static_cast< SdStyleSheet* >( xStyle.get() );
 124
 125     if( pStyle == nullptr || (pStyle->GetFamily() != mnFamily) || (pStyle->GetPool() != mxPool.get()) || (mxPool->Find( pStyle->GetName(), mnFamily) != nullptr) )
 126         throw IllegalArgumentException();
 127
 128     return pStyle;
 129 }
 130
 131 SdStyleSheet* SdStyleFamily::GetSheetByName( const OUString& rName )
 132 {
 133     SdStyleSheet* pRet = nullptr;
 134     if( !rName.isEmpty() )
 135     {
 136         if( mnFamily == SfxStyleFamily::Page )
 137         {
 138             PresStyleMap& rStyleMap = mpImpl->getStyleSheets();
 139             PresStyleMap::iterator iter( rStyleMap.find(rName) );
 140             if( iter != rStyleMap.end() )
 141                 pRet = (*iter).second.get();
 142         }
 143         else
 144         {
 145             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 146             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 147                                      pStyle = aSSSIterator->Next() )
 148             {
 149                 // we assume that we have only SdStyleSheets
 150                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 151                 if( pSdStyle && pSdStyle->GetApiName() == rName)
 152                 {
 153                     pRet = pSdStyle;
 154                     break;
 155                 }
 156             }
 157         }
 158     }
 159     if( pRet )
 160         return pRet;
 161
 162     throw NoSuchElementException();
 163 }
 164
 165 // XServiceInfo
 166 OUString SAL_CALL SdStyleFamily::getImplementationName()
 167 {
 168     return OUString( "SdStyleFamily" );
 169 }
 170
 171 sal_Bool SAL_CALL SdStyleFamily::supportsService( const OUString& ServiceName )
 172 {
 173     return cppu::supportsService( this, ServiceName );
 174 }
 175
 176 Sequence< OUString > SAL_CALL SdStyleFamily::getSupportedServiceNames()
 177 {
 178     OUString aServiceName( "com.sun.star.style.StyleFamily" );
 179     Sequence< OUString > aSeq( &aServiceName, 1 );
 180     return aSeq;
 181 }
 182
 183 // XNamed
 184 OUString SAL_CALL SdStyleFamily::getName()
 185 {
 186     if( mnFamily == SfxStyleFamily::Page )
 187     {
 188         SdPage* pPage = mpImpl->mxMasterPage.get();
 189         if( pPage == nullptr )
 190             throw DisposedException();
 191
 192         OUString aLayoutName( pPage->GetLayoutName() );
 193         const OUString aSep( SD_LT_SEPARATOR );
 194         sal_Int32 nIndex = aLayoutName.indexOf(aSep);
 195         if( nIndex != -1 )
 196             aLayoutName = aLayoutName.copy(0, nIndex);
 197
 198         return aLayoutName;
 199     }
 200     else
 201     {
 202         return SdStyleSheet::GetFamilyString( mnFamily );
 203     }
 204 }
 205
 206 void SAL_CALL SdStyleFamily::setName( const OUString& )
 207 {
 208 }
 209
 210 // XNameAccess
 211
 212 Any SAL_CALL SdStyleFamily::getByName( const OUString& rName )
 213 {
 214     SolarMutexGuard aGuard;
 215     throwIfDisposed();
 216     return Any( Reference< XStyle >( static_cast<SfxUnoStyleSheet*>(GetSheetByName( rName )) ) );
 217 }
 218
 219 Sequence< OUString > SAL_CALL SdStyleFamily::getElementNames()
 220 {
 221     SolarMutexGuard aGuard;
 222
 223     throwIfDisposed();
 224
 225     if( mnFamily == SfxStyleFamily::Page )
 226     {
 227         PresStyleMap& rStyleMap = mpImpl->getStyleSheets();
 228         Sequence< OUString > aNames( rStyleMap.size() );
 229
 230         PresStyleMap::iterator iter( rStyleMap.begin() );
 231         OUString* pNames = aNames.getArray();
 232         while( iter != rStyleMap.end() )
 233         {
 234             rtl::Reference< SdStyleSheet > xStyle( (*iter++).second );
 235             if( xStyle.is() )
 236             {
 237                 *pNames++ = xStyle->GetApiName();
 238             }
 239         }
 240
 241         return aNames;
 242     }
 243     else
 244     {
 245         std::vector< OUString > aNames;
 246         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 247         for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 248                                  pStyle = aSSSIterator->Next() )
 249         {
 250             // we assume that we have only SdStyleSheets
 251             SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 252             if( pSdStyle )
 253             {
 254                 aNames.push_back( pSdStyle->GetApiName() );
 255             }
 256         }
 257         return Sequence< OUString >( &(*aNames.begin()), aNames.size() );
 258     }
 259 }
 260
 261 sal_Bool SAL_CALL SdStyleFamily::hasByName( const OUString& aName )
 262 {
 263     SolarMutexGuard aGuard;
 264     throwIfDisposed();
 265
 266     if( !aName.isEmpty() )
 267     {
 268         if( mnFamily == SfxStyleFamily::Page )
 269         {
 270             PresStyleMap& rStyleSheets = mpImpl->getStyleSheets();
 271             PresStyleMap::iterator iter( rStyleSheets.find(aName) );
 272             return iter != rStyleSheets.end();
 273         }
 274         else
 275         {
 276             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 277             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 278                                      pStyle = aSSSIterator->Next() )
 279             {
 280                 // we assume that we have only SdStyleSheets
 281                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 282                 if( pSdStyle )
 283                 {
 284                     if (pSdStyle->GetApiName() == aName)
 285                     {
 286                         return true;
 287                     }
 288                 }
 289             }
 290         }
 291     }
 292
 293     return false;
 294 }
 295
 296 // XElementAccess
 297
 298 Type SAL_CALL SdStyleFamily::getElementType()
 299 {
 300     return cppu::UnoType<XStyle>::get();
 301 }
 302
 303 sal_Bool SAL_CALL SdStyleFamily::hasElements()
 304 {
 305     SolarMutexGuard aGuard;
 306     throwIfDisposed();
 307
 308     if( mnFamily == SfxStyleFamily::Page )
 309     {
 310         return true;
 311     }
 312     else
 313     {
 314         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 315         if (aSSSIterator->First())
 316         {
 317             return true;
 318         }
 319     }
 320
 321     return false;
 322 }
 323
 324 // XIndexAccess
 325
 326 sal_Int32 SAL_CALL SdStyleFamily::getCount()
 327 {
 328     SolarMutexGuard aGuard;
 329     throwIfDisposed();
 330
 331     sal_Int32 nCount = 0;
 332     if( mnFamily == SfxStyleFamily::Page )
 333     {
 334         return mpImpl->getStyleSheets().size();
 335     }
 336     else
 337     {
 338         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 339         for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 340                                  pStyle = aSSSIterator->Next() )
 341         {
 342             nCount++;
 343         }
 344     }
 345
 346     return nCount;
 347 }
 348
 349 Any SAL_CALL SdStyleFamily::getByIndex( sal_Int32 Index )
 350 {
 351     SolarMutexGuard aGuard;
 352     throwIfDisposed();
 353
 354     if( Index >= 0 )
 355     {
 356         if( mnFamily == SfxStyleFamily::Page )
 357         {
 358             PresStyleMap& rStyleSheets = mpImpl->getStyleSheets();
 359             if( !rStyleSheets.empty() )
 360             {
 361                 PresStyleMap::iterator iter( rStyleSheets.begin() );
 362                 while( Index-- && (iter != rStyleSheets.end()) )
 363                     ++iter;
 364
 365                 if( (Index==-1) && (iter != rStyleSheets.end()) )
 366                     return Any( Reference< XStyle >( (*iter).second.get() ) );
 367             }
 368         }
 369         else
 370         {
 371             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 372             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 373                                      pStyle = aSSSIterator->Next() )
 374             {
 375                 // we assume that we have only SdStyleSheets
 376                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 377                 if( Index-- == 0 )
 378                 {
 379                     return Any( Reference< XStyle >( pSdStyle ) );
 380                 }
 381             }
 382         }
 383     }
 384
 385     throw IndexOutOfBoundsException();
 386 }
 387
 388 // XNameContainer
 389
 390 void SAL_CALL SdStyleFamily::insertByName( const OUString& rName, const Any& rElement )
 391 {
 392     SolarMutexGuard aGuard;
 393     throwIfDisposed();
 394
 395     if(rName.isEmpty())
 396         throw IllegalArgumentException();
 397
 398     SdStyleSheet* pStyle = GetValidNewSheet( rElement );
 399     if( !pStyle->SetName( rName ) )
 400         throw ElementExistException();
 401
 402     pStyle->SetApiName( rName );
 403     mxPool->Insert( pStyle );
 404 }
 405
 406 void SAL_CALL SdStyleFamily::removeByName( const OUString& rName )
 407 {
 408     SolarMutexGuard aGuard;
 409     throwIfDisposed();
 410
 411     SdStyleSheet* pStyle = GetSheetByName( rName );
 412
 413     if( !pStyle->IsUserDefined() )
 414         throw WrappedTargetException();
 415
 416     mxPool->Remove( pStyle );
 417 }
 418
 419 // XNameReplace
 420
 421 void SAL_CALL SdStyleFamily::replaceByName( const OUString& rName, const Any& aElement )
 422 {
 423     SolarMutexGuard aGuard;
 424     throwIfDisposed();
 425
 426     SdStyleSheet* pOldStyle = GetSheetByName( rName );
 427     SdStyleSheet* pNewStyle = GetValidNewSheet( aElement );
 428
 429     mxPool->Remove( pOldStyle );
 430     mxPool->Insert( pNewStyle );
 431 }
 432
 433 // XSingleServiceFactory
 434
 435 Reference< XInterface > SAL_CALL SdStyleFamily::createInstance()
 436 {
 437     SolarMutexGuard aGuard;
 438     throwIfDisposed();
 439
 440     if( mnFamily == SfxStyleFamily::Page )
 441     {
 442         throw IllegalAccessException();
 443     }
 444     return Reference< XInterface >( static_cast< XStyle* >( SdStyleSheet::CreateEmptyUserStyle( *mxPool.get(), mnFamily ) ) );
 445 }
 446
 447 Reference< XInterface > SAL_CALL SdStyleFamily::createInstanceWithArguments( const Sequence< Any >&  )
 448 {
 449     return createInstance();
 450 }
 451
 452 // XComponent
 453
 454 void SAL_CALL SdStyleFamily::dispose(  )
 455 {
 456     if( mxPool.is() )
 457         mxPool.clear();
 458
 459     mpImpl.reset();
 460 }
 461
 462 void SAL_CALL SdStyleFamily::addEventListener( const Reference< XEventListener >&  )
 463 {
 464 }
 465
 466 void SAL_CALL SdStyleFamily::removeEventListener( const Reference< XEventListener >&  )
 467 {
 468 }
 469
 470 // XPropertySet
 471
 472 Reference<XPropertySetInfo> SdStyleFamily::getPropertySetInfo()
 473 {
 474     OSL_FAIL( "###unexpected!" );
 475     return Reference<XPropertySetInfo>();
 476 }
 477
 478 void SdStyleFamily::setPropertyValue( const OUString& , const Any&  )
 479 {
 480     OSL_FAIL( "###unexpected!" );
 481 }
 482
 483 Any SdStyleFamily::getPropertyValue( const OUString& PropertyName )
 484 {
 485     if ( PropertyName != "DisplayName" )
 486     {
 487         throw UnknownPropertyException( "unknown property: " + PropertyName, static_cast<OWeakObject *>(this) );
 488     }
 489
 490     SolarMutexGuard aGuard;
 491     OUString sDisplayName;
 492     switch( mnFamily )
 493     {
 494         case SfxStyleFamily::Page:    sDisplayName = getName(); break;
 495         case SfxStyleFamily::Frame:          sDisplayName = SdResId(STR_CELL_STYLE_FAMILY); break;
 496         default:                            sDisplayName = SdResId(STR_GRAPHICS_STYLE_FAMILY); break;
 497     }
 498     return Any( sDisplayName );
 499 }
 500
 501 void SdStyleFamily::addPropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 502 {
 503     OSL_FAIL( "###unexpected!" );
 504 }
 505
 506 void SdStyleFamily::removePropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 507 {
 508     OSL_FAIL( "###unexpected!" );
 509 }
 510
 511 void SdStyleFamily::addVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>& )
 512 {
 513     OSL_FAIL( "###unexpected!" );
 514 }
 515
 516 void SdStyleFamily::removeVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>&  )
 517 {
 518     OSL_FAIL( "###unexpected!" );
 519 }
 520
 521 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */