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 <tools/weakbase.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     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->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 "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     return { "com.sun.star.style.StyleFamily" };
 179 }
 180
 181 // XNamed
 182 OUString SAL_CALL SdStyleFamily::getName()
 183 {
 184     if( mnFamily == SfxStyleFamily::Page )
 185     {
 186         SdPage* pPage = mpImpl->mxMasterPage.get();
 187         if( pPage == nullptr )
 188             throw DisposedException();
 189
 190         OUString aLayoutName( pPage->GetLayoutName() );
 191         sal_Int32 nIndex = aLayoutName.indexOf(SD_LT_SEPARATOR);
 192         if( nIndex != -1 )
 193             aLayoutName = aLayoutName.copy(0, nIndex);
 194
 195         return aLayoutName;
 196     }
 197     else
 198     {
 199         return SdStyleSheet::GetFamilyString( mnFamily );
 200     }
 201 }
 202
 203 void SAL_CALL SdStyleFamily::setName( const OUString& )
 204 {
 205 }
 206
 207 // XNameAccess
 208
 209 Any SAL_CALL SdStyleFamily::getByName( const OUString& rName )
 210 {
 211     SolarMutexGuard aGuard;
 212     throwIfDisposed();
 213     return Any( Reference< XStyle >( static_cast<SfxUnoStyleSheet*>(GetSheetByName( rName )) ) );
 214 }
 215
 216 Sequence< OUString > SAL_CALL SdStyleFamily::getElementNames()
 217 {
 218     SolarMutexGuard aGuard;
 219
 220     throwIfDisposed();
 221
 222     if( mnFamily == SfxStyleFamily::Page )
 223     {
 224         PresStyleMap& rStyleMap = mpImpl->getStyleSheets();
 225         Sequence< OUString > aNames( rStyleMap.size() );
 226
 227         OUString* pNames = aNames.getArray();
 228         for( const auto& rEntry : rStyleMap )
 229         {
 230             rtl::Reference< SdStyleSheet > xStyle( rEntry.second );
 231             if( xStyle.is() )
 232             {
 233                 *pNames++ = xStyle->GetApiName();
 234             }
 235         }
 236
 237         return aNames;
 238     }
 239     else
 240     {
 241         std::vector< OUString > aNames;
 242         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 243         for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 244                                  pStyle = aSSSIterator->Next() )
 245         {
 246             // we assume that we have only SdStyleSheets
 247             SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 248             aNames.push_back(pSdStyle->GetApiName());
 249         }
 250         return Sequence< OUString >( &(*aNames.begin()), aNames.size() );
 251     }
 252 }
 253
 254 sal_Bool SAL_CALL SdStyleFamily::hasByName( const OUString& aName )
 255 {
 256     SolarMutexGuard aGuard;
 257     throwIfDisposed();
 258
 259     if( !aName.isEmpty() )
 260     {
 261         if( mnFamily == SfxStyleFamily::Page )
 262         {
 263             PresStyleMap& rStyleSheets = mpImpl->getStyleSheets();
 264             PresStyleMap::iterator iter( rStyleSheets.find(aName) );
 265             return iter != rStyleSheets.end();
 266         }
 267         else
 268         {
 269             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 270             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 271                                      pStyle = aSSSIterator->Next() )
 272             {
 273                 // we assume that we have only SdStyleSheets
 274                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 275                 if (pSdStyle->GetApiName() == aName)
 276                 {
 277                     return true;
 278                 }
 279             }
 280         }
 281     }
 282
 283     return false;
 284 }
 285
 286 // XElementAccess
 287
 288 Type SAL_CALL SdStyleFamily::getElementType()
 289 {
 290     return cppu::UnoType<XStyle>::get();
 291 }
 292
 293 sal_Bool SAL_CALL SdStyleFamily::hasElements()
 294 {
 295     SolarMutexGuard aGuard;
 296     throwIfDisposed();
 297
 298     if( mnFamily == SfxStyleFamily::Page )
 299     {
 300         return true;
 301     }
 302     else
 303     {
 304         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 305         if (aSSSIterator->First())
 306         {
 307             return true;
 308         }
 309     }
 310
 311     return false;
 312 }
 313
 314 // XIndexAccess
 315
 316 sal_Int32 SAL_CALL SdStyleFamily::getCount()
 317 {
 318     SolarMutexGuard aGuard;
 319     throwIfDisposed();
 320
 321     sal_Int32 nCount = 0;
 322     if( mnFamily == SfxStyleFamily::Page )
 323     {
 324         return mpImpl->getStyleSheets().size();
 325     }
 326     else
 327     {
 328         std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 329         for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 330                                  pStyle = aSSSIterator->Next() )
 331         {
 332             nCount++;
 333         }
 334     }
 335
 336     return nCount;
 337 }
 338
 339 Any SAL_CALL SdStyleFamily::getByIndex( sal_Int32 Index )
 340 {
 341     SolarMutexGuard aGuard;
 342     throwIfDisposed();
 343
 344     if( Index >= 0 )
 345     {
 346         if( mnFamily == SfxStyleFamily::Page )
 347         {
 348             PresStyleMap& rStyleSheets = mpImpl->getStyleSheets();
 349             if( Index < static_cast<sal_Int32>(rStyleSheets.size()) )
 350             {
 351                 PresStyleMap::iterator iter( rStyleSheets.begin() );
 352                 std::advance(iter, Index);
 353                 return Any( Reference< XStyle >( (*iter).second.get() ) );
 354             }
 355         }
 356         else
 357         {
 358             std::shared_ptr<SfxStyleSheetIterator> aSSSIterator = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), mnFamily);
 359             for ( SfxStyleSheetBase* pStyle = aSSSIterator->First(); pStyle;
 360                                      pStyle = aSSSIterator->Next() )
 361             {
 362                 // we assume that we have only SdStyleSheets
 363                 SdStyleSheet* pSdStyle = static_cast< SdStyleSheet* >( pStyle );
 364                 if( Index-- == 0 )
 365                 {
 366                     return Any( Reference< XStyle >( pSdStyle ) );
 367                 }
 368             }
 369         }
 370     }
 371
 372     throw IndexOutOfBoundsException();
 373 }
 374
 375 // XNameContainer
 376
 377 void SAL_CALL SdStyleFamily::insertByName( const OUString& rName, const Any& rElement )
 378 {
 379     SolarMutexGuard aGuard;
 380     throwIfDisposed();
 381
 382     if(rName.isEmpty())
 383         throw IllegalArgumentException();
 384
 385     SdStyleSheet* pStyle = GetValidNewSheet( rElement );
 386     if( !pStyle->SetName( rName ) )
 387         throw ElementExistException();
 388
 389     pStyle->SetApiName( rName );
 390     mxPool->Insert( pStyle );
 391 }
 392
 393 void SAL_CALL SdStyleFamily::removeByName( const OUString& rName )
 394 {
 395     SolarMutexGuard aGuard;
 396     throwIfDisposed();
 397
 398     SdStyleSheet* pStyle = GetSheetByName( rName );
 399
 400     if( !pStyle->IsUserDefined() )
 401         throw WrappedTargetException();
 402
 403     mxPool->Remove( pStyle );
 404 }
 405
 406 // XNameReplace
 407
 408 void SAL_CALL SdStyleFamily::replaceByName( const OUString& rName, const Any& aElement )
 409 {
 410     SolarMutexGuard aGuard;
 411     throwIfDisposed();
 412
 413     SdStyleSheet* pOldStyle = GetSheetByName( rName );
 414     SdStyleSheet* pNewStyle = GetValidNewSheet( aElement );
 415
 416     mxPool->Remove( pOldStyle );
 417     mxPool->Insert( pNewStyle );
 418 }
 419
 420 // XSingleServiceFactory
 421
 422 Reference< XInterface > SAL_CALL SdStyleFamily::createInstance()
 423 {
 424     SolarMutexGuard aGuard;
 425     throwIfDisposed();
 426
 427     if( mnFamily == SfxStyleFamily::Page )
 428     {
 429         throw IllegalAccessException();
 430     }
 431     return Reference<XInterface>(
 432         static_cast<XStyle*>(SdStyleSheet::CreateEmptyUserStyle(*mxPool, mnFamily)));
 433 }
 434
 435 Reference< XInterface > SAL_CALL SdStyleFamily::createInstanceWithArguments( const Sequence< Any >&  )
 436 {
 437     return createInstance();
 438 }
 439
 440 // XComponent
 441
 442 void SAL_CALL SdStyleFamily::dispose(  )
 443 {
 444     if( mxPool.is() )
 445         mxPool.clear();
 446
 447     mpImpl.reset();
 448 }
 449
 450 void SAL_CALL SdStyleFamily::addEventListener( const Reference< XEventListener >&  )
 451 {
 452 }
 453
 454 void SAL_CALL SdStyleFamily::removeEventListener( const Reference< XEventListener >&  )
 455 {
 456 }
 457
 458 // XPropertySet
 459
 460 Reference<XPropertySetInfo> SdStyleFamily::getPropertySetInfo()
 461 {
 462     OSL_FAIL( "###unexpected!" );
 463     return Reference<XPropertySetInfo>();
 464 }
 465
 466 void SdStyleFamily::setPropertyValue( const OUString& , const Any&  )
 467 {
 468     OSL_FAIL( "###unexpected!" );
 469 }
 470
 471 Any SdStyleFamily::getPropertyValue( const OUString& PropertyName )
 472 {
 473     if ( PropertyName != "DisplayName" )
 474     {
 475         throw UnknownPropertyException( "unknown property: " + PropertyName, static_cast<OWeakObject *>(this) );
 476     }
 477
 478     SolarMutexGuard aGuard;
 479     OUString sDisplayName;
 480     switch( mnFamily )
 481     {
 482         case SfxStyleFamily::Page:    sDisplayName = getName(); break;
 483         case SfxStyleFamily::Frame:          sDisplayName = SdResId(STR_CELL_STYLE_FAMILY); break;
 484         default:                            sDisplayName = SdResId(STR_GRAPHICS_STYLE_FAMILY); break;
 485     }
 486     return Any( sDisplayName );
 487 }
 488
 489 void SdStyleFamily::addPropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 490 {
 491     OSL_FAIL( "###unexpected!" );
 492 }
 493
 494 void SdStyleFamily::removePropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 495 {
 496     OSL_FAIL( "###unexpected!" );
 497 }
 498
 499 void SdStyleFamily::addVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>& )
 500 {
 501     OSL_FAIL( "###unexpected!" );
 502 }
 503
 504 void SdStyleFamily::removeVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>&  )
 505 {
 506     OSL_FAIL( "###unexpected!" );
 507 }
 508
 509 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */