svx/source/unogallery/unogaltheme.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 <algorithm>
  21
  22 #include "unogaltheme.hxx"
  23 #include "unogalitem.hxx"
  24 #include "svx/galtheme.hxx"
  25 #include "svx/gallery1.hxx"
  26 #include "svx/galmisc.hxx"
  27 #include <svx/fmmodel.hxx>
  28 #include <svx/svdpage.hxx>
  29 #include <svx/unopage.hxx>
  30 #include <svl/itempool.hxx>
  31 #include <osl/mutex.hxx>
  32 #include <vcl/svapp.hxx>
  33 #include <unotools/pathoptions.hxx>
  34 #include <comphelper/servicehelper.hxx>
  35
  36 using namespace ::com::sun::star;
  37
  38 namespace unogallery {
  39
  40 // -----------------
  41 // - GalleryTheme -
  42 // -----------------
  43
  44 GalleryTheme::GalleryTheme( const OUString& rThemeName )
  45 {
  46     mpGallery = ::Gallery::GetGalleryInstance();
  47     mpTheme = ( mpGallery ? mpGallery->AcquireTheme( rThemeName, *this ) : NULL );
  48
  49     if( mpGallery )
  50         StartListening( *mpGallery );
  51 }
  52
  53 // ------------------------------------------------------------------------------
  54
  55 GalleryTheme::~GalleryTheme()
  56 {
  57     const SolarMutexGuard aGuard;
  58
  59     DBG_ASSERT( !mpTheme || mpGallery, "Theme is living without Gallery" );
  60
  61     implReleaseItems( NULL );
  62
  63     if( mpGallery )
  64     {
  65         EndListening( *mpGallery );
  66
  67         if( mpTheme )
  68             mpGallery->ReleaseTheme( mpTheme, *this );
  69     }
  70 }
  71
  72 // ------------------------------------------------------------------------------
  73
  74 OUString GalleryTheme::getImplementationName_Static()
  75     throw()
  76 {
  77     return OUString( "com.sun.star.comp.gallery.GalleryTheme" );
  78 }
  79
  80 // ------------------------------------------------------------------------------
  81
  82 uno::Sequence< OUString > GalleryTheme::getSupportedServiceNames_Static()
  83     throw()
  84 {
  85     uno::Sequence< OUString > aSeq( 1 );
  86
  87     aSeq.getArray()[ 0 ] = OUString( "com.sun.star.gallery.GalleryTheme" );
  88
  89     return aSeq;
  90 }
  91
  92 // ------------------------------------------------------------------------------
  93
  94 OUString SAL_CALL GalleryTheme::getImplementationName()
  95     throw( uno::RuntimeException )
  96 {
  97     return getImplementationName_Static();
  98 }
  99
 100 // ------------------------------------------------------------------------------
 101
 102 sal_Bool SAL_CALL GalleryTheme::supportsService( const OUString& ServiceName )
 103     throw( uno::RuntimeException )
 104 {
 105     uno::Sequence< OUString >    aSNL( getSupportedServiceNames() );
 106     const OUString*              pArray = aSNL.getConstArray();
 107
 108     for( int i = 0; i < aSNL.getLength(); i++ )
 109         if( pArray[i] == ServiceName )
 110             return true;
 111
 112     return false;
 113 }
 114
 115 // ------------------------------------------------------------------------------
 116
 117 uno::Sequence< OUString > SAL_CALL GalleryTheme::getSupportedServiceNames()
 118     throw( uno::RuntimeException )
 119 {
 120     return getSupportedServiceNames_Static();
 121 }
 122
 123 // ------------------------------------------------------------------------------
 124
 125 uno::Sequence< uno::Type > SAL_CALL GalleryTheme::getTypes()
 126     throw(uno::RuntimeException)
 127 {
 128     uno::Sequence< uno::Type >  aTypes( 5 );
 129     uno::Type*                  pTypes = aTypes.getArray();
 130
 131     *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo>*)0);
 132     *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider>*)0);
 133     *pTypes++ = ::getCppuType((const uno::Reference< container::XElementAccess>*)0);
 134     *pTypes++ = ::getCppuType((const uno::Reference< container::XIndexAccess>*)0);
 135     *pTypes++ = ::getCppuType((const uno::Reference< gallery::XGalleryTheme>*)0);
 136
 137     return aTypes;
 138 }
 139
 140 namespace
 141 {
 142     class theGalleryThemeImplementationId : public rtl::Static< UnoTunnelIdInit, theGalleryThemeImplementationId > {};
 143 }
 144
 145 uno::Sequence< sal_Int8 > SAL_CALL GalleryTheme::getImplementationId()
 146     throw(uno::RuntimeException)
 147 {
 148     return theGalleryThemeImplementationId::get().getSeq();
 149 }
 150
 151 // ------------------------------------------------------------------------------
 152
 153 uno::Type SAL_CALL GalleryTheme::getElementType()
 154     throw (uno::RuntimeException)
 155 {
 156     return ::getCppuType( (const uno::Reference< gallery::XGalleryItem >*) 0);
 157 }
 158
 159 // ------------------------------------------------------------------------------
 160
 161 sal_Bool SAL_CALL GalleryTheme::hasElements()
 162     throw (uno::RuntimeException)
 163 {
 164     const SolarMutexGuard aGuard;
 165
 166     return( ( mpTheme != NULL ) && ( mpTheme->GetObjectCount() > 0 ) );
 167 }
 168
 169 // ------------------------------------------------------------------------------
 170
 171 sal_Int32 SAL_CALL GalleryTheme::getCount()
 172     throw (uno::RuntimeException)
 173 {
 174     const SolarMutexGuard aGuard;
 175
 176     return( mpTheme ? mpTheme->GetObjectCount() : 0 );
 177 }
 178
 179 // ------------------------------------------------------------------------------
 180
 181 uno::Any SAL_CALL GalleryTheme::getByIndex( ::sal_Int32 nIndex )
 182     throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
 183 {
 184     const SolarMutexGuard aGuard;
 185     uno::Any            aRet;
 186
 187     if( mpTheme )
 188     {
 189         if( ( nIndex < 0 ) || ( nIndex >= getCount() ) )
 190         {
 191             throw lang::IndexOutOfBoundsException();
 192         }
 193         else
 194         {
 195             const GalleryObject* pObj = mpTheme->ImplGetGalleryObject( nIndex );
 196
 197             if( pObj )
 198                 aRet = uno::makeAny( uno::Reference< gallery::XGalleryItem >( new GalleryItem( *this, *pObj ) ) );
 199         }
 200     }
 201
 202     return aRet;
 203 }
 204
 205 // ------------------------------------------------------------------------------
 206
 207 OUString SAL_CALL GalleryTheme::getName(  )
 208     throw (uno::RuntimeException)
 209 {
 210     const SolarMutexGuard aGuard;
 211     OUString     aRet;
 212
 213     if( mpTheme )
 214         aRet = mpTheme->GetName();
 215
 216     return aRet;
 217 }
 218
 219 // ------------------------------------------------------------------------------
 220
 221 void SAL_CALL GalleryTheme::update(  )
 222     throw (uno::RuntimeException)
 223 {
 224     const SolarMutexGuard aGuard;
 225
 226     if( mpTheme )
 227     {
 228         const Link aDummyLink;
 229         mpTheme->Actualize( aDummyLink );
 230     }
 231 }
 232
 233 // ------------------------------------------------------------------------------
 234
 235 ::sal_Int32 SAL_CALL GalleryTheme::insertURLByIndex(
 236     const OUString& rURL, ::sal_Int32 nIndex )
 237     throw (lang::WrappedTargetException, uno::RuntimeException)
 238 {
 239     const SolarMutexGuard aGuard;
 240     sal_Int32           nRet = -1;
 241
 242     if( mpTheme )
 243     {
 244         try
 245         {
 246             const INetURLObject aURL( rURL );
 247
 248             nIndex = ::std::max( ::std::min( nIndex, getCount() ), sal_Int32( 0 ) );
 249
 250             if( ( aURL.GetProtocol() != INET_PROT_NOT_VALID ) && mpTheme->InsertURL( aURL, nIndex ) )
 251             {
 252                 const GalleryObject* pObj = mpTheme->ImplGetGalleryObject( aURL );
 253
 254                 if( pObj )
 255                     nRet = mpTheme->ImplGetGalleryObjectPos( pObj );
 256             }
 257         }
 258         catch( ... )
 259         {
 260         }
 261     }
 262
 263     return nRet;
 264 }
 265
 266 // ------------------------------------------------------------------------------
 267
 268 ::sal_Int32 SAL_CALL GalleryTheme::insertGraphicByIndex(
 269     const uno::Reference< graphic::XGraphic >& rxGraphic, sal_Int32 nIndex )
 270     throw (lang::WrappedTargetException, uno::RuntimeException)
 271 {
 272     const SolarMutexGuard aGuard;
 273     sal_Int32           nRet = -1;
 274
 275     if( mpTheme )
 276     {
 277         try
 278         {
 279             const Graphic aGraphic( rxGraphic );
 280
 281             nIndex = ::std::max( ::std::min( nIndex, getCount() ), sal_Int32( 0 ) );
 282
 283             if( mpTheme->InsertGraphic( aGraphic, nIndex ) )
 284                 nRet = nIndex;
 285         }
 286         catch( ... )
 287         {
 288         }
 289     }
 290
 291     return nRet;
 292 }
 293
 294 // ------------------------------------------------------------------------------
 295
 296 ::sal_Int32 SAL_CALL GalleryTheme::insertDrawingByIndex(
 297     const uno::Reference< lang::XComponent >& Drawing, sal_Int32 nIndex )
 298     throw (lang::WrappedTargetException, uno::RuntimeException)
 299 {
 300     const SolarMutexGuard aGuard;
 301     sal_Int32 nRet = -1;
 302
 303     if( mpTheme )
 304     {
 305         GalleryDrawingModel* pModel = GalleryDrawingModel::getImplementation( Drawing );
 306
 307         if( pModel && pModel->GetDoc() && pModel->GetDoc()->ISA( FmFormModel ) )
 308         {
 309             // Here we're inserting something that's already a gallery theme drawing
 310             nIndex = ::std::max( ::std::min( nIndex, getCount() ), sal_Int32( 0 ) );
 311
 312             if( mpTheme->InsertModel( *static_cast< FmFormModel* >( pModel->GetDoc() ), nIndex ) )
 313                 nRet = nIndex;
 314         }
 315         else if (!pModel)
 316         {
 317             // #i80184# Try to do the right thing and make a Gallery drawing out
 318             // of an ordinary Drawing if possible.
 319             try
 320             {
 321                 uno::Reference< drawing::XDrawPagesSupplier > xDrawPagesSupplier( Drawing, uno::UNO_QUERY_THROW );
 322                 uno::Reference< drawing::XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), uno::UNO_QUERY_THROW );
 323                 uno::Reference< drawing::XDrawPage > xPage( xDrawPages->getByIndex( 0 ), uno::UNO_QUERY_THROW );
 324                 SvxDrawPage* pUnoPage = xPage.is() ? SvxDrawPage::getImplementation( xPage ) : NULL;
 325                 SdrModel* pOrigModel = pUnoPage ? pUnoPage->GetSdrPage()->GetModel() : NULL;
 326                 SdrPage* pOrigPage = pUnoPage ? pUnoPage->GetSdrPage() : NULL;
 327
 328                 if (pOrigPage && pOrigModel)
 329                 {
 330                     FmFormModel* pTmpModel = new FmFormModel(&pOrigModel->GetItemPool());
 331                     SdrPage* pNewPage = pOrigPage->Clone();
 332                     pTmpModel->InsertPage(pNewPage, 0);
 333
 334                     uno::Reference< lang::XComponent > xDrawing( new GalleryDrawingModel( pTmpModel ) );
 335                     pTmpModel->setUnoModel( uno::Reference< uno::XInterface >::query( xDrawing ) );
 336
 337                     nRet = insertDrawingByIndex( xDrawing, nIndex );
 338                     return nRet;
 339                 }
 340             }
 341             catch (...)
 342             {
 343             }
 344         }
 345     }
 346
 347     return nRet;
 348 }
 349
 350 // ------------------------------------------------------------------------------
 351
 352 void SAL_CALL GalleryTheme::removeByIndex( sal_Int32 nIndex )
 353     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 354 {
 355     const SolarMutexGuard aGuard;
 356
 357     if( mpTheme )
 358     {
 359         if( ( nIndex < 0 ) || ( nIndex >= getCount() ) )
 360             throw lang::IndexOutOfBoundsException();
 361         else
 362             mpTheme->RemoveObject( nIndex );
 363     }
 364 }
 365
 366 // ------------------------------------------------------------------------------
 367
 368 void GalleryTheme::Notify( SfxBroadcaster&, const SfxHint& rHint )
 369 {
 370     const SolarMutexGuard aGuard;
 371     const GalleryHint&  rGalleryHint = static_cast< const GalleryHint& >( rHint );
 372
 373     switch( rGalleryHint.GetType() )
 374     {
 375         case( GALLERY_HINT_CLOSE_THEME ):
 376         {
 377             DBG_ASSERT( !mpTheme || mpGallery, "Theme is living without Gallery" );
 378
 379             implReleaseItems( NULL );
 380
 381             if( mpGallery && mpTheme )
 382             {
 383                 mpGallery->ReleaseTheme( mpTheme, *this );
 384                 mpTheme = NULL;
 385             }
 386         }
 387         break;
 388
 389         case( GALLERY_HINT_CLOSE_OBJECT ):
 390         {
 391             GalleryObject* pObj = reinterpret_cast< GalleryObject* >( rGalleryHint.GetData1() );
 392
 393             if( pObj )
 394                 implReleaseItems( pObj );
 395         }
 396         break;
 397
 398         default:
 399         break;
 400     }
 401 }
 402
 403 // ------------------------------------------------------------------------------
 404
 405 void GalleryTheme::implReleaseItems( GalleryObject* pObj )
 406 {
 407     const SolarMutexGuard aGuard;
 408
 409     for( GalleryItemList::iterator aIter = maItemList.begin(); aIter != maItemList.end();  )
 410     {
 411         if( !pObj || ( (*aIter)->implGetObject() == pObj ) )
 412         {
 413             (*aIter)->implSetInvalid();
 414             aIter = maItemList.erase( aIter );
 415         }
 416         else
 417             ++aIter;
 418     }
 419 }
 420
 421 // ------------------------------------------------------------------------------
 422
 423 ::GalleryTheme* GalleryTheme::implGetTheme() const
 424 {
 425     return mpTheme;
 426 }
 427
 428 // ------------------------------------------------------------------------------
 429
 430 void GalleryTheme::implRegisterGalleryItem( ::unogallery::GalleryItem& rItem )
 431 {
 432     const SolarMutexGuard aGuard;
 433
 434 //  DBG_ASSERT( maItemList.find( &rItem ) == maItemList.end(), "Item already registered" );
 435     maItemList.push_back( &rItem );
 436 }
 437
 438 // ------------------------------------------------------------------------------
 439
 440 void GalleryTheme::implDeregisterGalleryItem( ::unogallery::GalleryItem& rItem )
 441 {
 442     const SolarMutexGuard aGuard;
 443
 444 //  DBG_ASSERT( maItemList.find( &rItem ) != maItemList.end(), "Item is not registered" );
 445     maItemList.remove( &rItem );
 446 }
 447
 448 }
 449
 450 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */