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