sd/source/ui/presenter/PresenterPreviewCache.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PresenterPreviewCache.cxx,v $
  10  *
  11  * $Revision: 1.6 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "precompiled_sd.hxx"
  35
  36 #include "PresenterPreviewCache.hxx"
  37
  38 #include "cache/SlsCacheContext.hxx"
  39 #include "tools/IdleDetection.hxx"
  40 #include "sdpage.hxx"
  41 #include <cppcanvas/vclfactory.hxx>
  42 #include <com/sun/star/drawing/XDrawPage.hpp>
  43 #include <com/sun/star/rendering/XBitmapCanvas.hpp>
  44
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::uno;
  47 using namespace ::sd::slidesorter::cache;
  48 using ::rtl::OUString;
  49
  50 namespace sd { namespace presenter {
  51
  52
  53 class PresenterPreviewCache::PresenterCacheContext : public CacheContext
  54 {
  55 public:
  56     PresenterCacheContext (void);
  57     virtual ~PresenterCacheContext (void);
  58
  59     void SetDocumentSlides (
  60         const Reference<container::XIndexAccess>& rxSlides,
  61         const Reference<XInterface>& rxDocument);
  62     void SetVisibleSlideRange (
  63         const sal_Int32 nFirstVisibleSlideIndex,
  64         const sal_Int32 nLastVisibleSlideIndex);
  65     const SdrPage* GetPage (const sal_Int32 nSlideIndex) const;
  66     void AddPreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
  67     void RemovePreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
  68
  69     // CacheContext
  70     virtual void NotifyPreviewCreation (
  71         CacheKey aKey, const ::boost::shared_ptr<BitmapEx>& rPreview);
  72     virtual bool IsIdle (void);
  73     virtual bool IsVisible (CacheKey aKey);
  74     virtual const SdrPage* GetPage (CacheKey aKey);
  75     virtual ::boost::shared_ptr<std::vector<CacheKey> > GetEntryList (bool bVisible);
  76     virtual sal_Int32 GetPriority (CacheKey aKey);
  77     virtual ::com::sun::star::uno::Reference<com::sun::star::uno::XInterface> GetModel (void);
  78
  79 private:
  80     Reference<container::XIndexAccess> mxSlides;
  81     Reference<XInterface> mxDocument;
  82     sal_Int32 mnFirstVisibleSlideIndex;
  83     sal_Int32 mnLastVisibleSlideIndex;
  84     typedef ::std::vector<css::uno::Reference<css::drawing::XSlidePreviewCacheListener> > ListenerContainer;
  85     ListenerContainer maListeners;
  86
  87     void CallListeners (const sal_Int32 nSlideIndex);
  88 };
  89
  90
  91
  92
  93 //===== Service ===============================================================
  94
  95 Reference<XInterface> SAL_CALL PresenterPreviewCache_createInstance (
  96     const Reference<XComponentContext>& rxContext)
  97 {
  98     return Reference<XInterface>(static_cast<XWeak*>(new PresenterPreviewCache(rxContext)));
  99 }
 100
 101
 102
 103
 104 ::rtl::OUString PresenterPreviewCache_getImplementationName (void) throw(RuntimeException)
 105 {
 106     return OUString::createFromAscii("com.sun.star.comp.Draw.PresenterPreviewCache");
 107 }
 108
 109
 110
 111
 112 Sequence<rtl::OUString> SAL_CALL PresenterPreviewCache_getSupportedServiceNames (void)
 113     throw (RuntimeException)
 114 {
 115     static const ::rtl::OUString sServiceName(
 116         ::rtl::OUString::createFromAscii("com.sun.star.drawing.PresenterPreviewCache"));
 117     return Sequence<rtl::OUString>(&sServiceName, 1);
 118 }
 119
 120
 121
 122
 123 //===== PresenterPreviewCache =================================================
 124
 125 PresenterPreviewCache::PresenterPreviewCache (const Reference<XComponentContext>& rxContext)
 126     : PresenterPreviewCacheInterfaceBase(m_aMutex),
 127       maPreviewSize(Size(200,200)),
 128       mpCacheContext(new PresenterCacheContext()),
 129       mpCache(new PageCache(maPreviewSize, mpCacheContext))
 130 {
 131     (void)rxContext;
 132 }
 133
 134
 135
 136
 137 PresenterPreviewCache::~PresenterPreviewCache (void)
 138 {
 139 }
 140
 141
 142
 143
 144 //----- XInitialize -----------------------------------------------------------
 145
 146 void SAL_CALL PresenterPreviewCache::initialize (const Sequence<Any>& rArguments)
 147     throw(Exception, RuntimeException)
 148 {
 149     if (rArguments.getLength() != 0)
 150         throw RuntimeException();
 151 }
 152
 153
 154
 155
 156 //----- XSlidePreviewCache ----------------------------------------------------
 157
 158 void SAL_CALL PresenterPreviewCache::setDocumentSlides (
 159     const Reference<container::XIndexAccess>& rxSlides,
 160     const Reference<XInterface>& rxDocument)
 161     throw (RuntimeException)
 162 {
 163     ThrowIfDisposed();
 164     OSL_ASSERT(mpCacheContext.get()!=NULL);
 165
 166     mpCacheContext->SetDocumentSlides(rxSlides, rxDocument);
 167 }
 168
 169
 170
 171
 172 void SAL_CALL PresenterPreviewCache::setVisibleRange (
 173     sal_Int32 nFirstVisibleSlideIndex,
 174     sal_Int32 nLastVisibleSlideIndex)
 175     throw (css::uno::RuntimeException)
 176 {
 177     ThrowIfDisposed();
 178     OSL_ASSERT(mpCacheContext.get()!=NULL);
 179
 180     mpCacheContext->SetVisibleSlideRange (nFirstVisibleSlideIndex, nLastVisibleSlideIndex);
 181 }
 182
 183
 184
 185
 186 void SAL_CALL PresenterPreviewCache::setPreviewSize (
 187     const css::geometry::IntegerSize2D& rSize)
 188     throw (css::uno::RuntimeException)
 189 {
 190     ThrowIfDisposed();
 191     OSL_ASSERT(mpCache.get()!=NULL);
 192
 193     maPreviewSize = Size(rSize.Width, rSize.Height);
 194     mpCache->ChangeSize(maPreviewSize);
 195 }
 196
 197
 198
 199
 200 Reference<rendering::XBitmap> SAL_CALL PresenterPreviewCache::getSlidePreview (
 201     sal_Int32 nSlideIndex,
 202     const Reference<rendering::XCanvas>& rxCanvas)
 203     throw (css::uno::RuntimeException)
 204 {
 205     ThrowIfDisposed();
 206     OSL_ASSERT(mpCacheContext.get()!=NULL);
 207
 208     cppcanvas::BitmapCanvasSharedPtr pCanvas (
 209         cppcanvas::VCLFactory::getInstance().createCanvas(
 210             Reference<rendering::XBitmapCanvas>(rxCanvas, UNO_QUERY)));
 211
 212     const SdrPage* pPage = mpCacheContext->GetPage(nSlideIndex);
 213     if (pPage == NULL)
 214         throw RuntimeException();
 215
 216     const BitmapEx aPreview (mpCache->GetPreviewBitmap(pPage, maPreviewSize));
 217     if (aPreview.IsEmpty())
 218         return NULL;
 219     else
 220         return cppcanvas::VCLFactory::getInstance().createBitmap(
 221             pCanvas,
 222             aPreview)->getUNOBitmap();
 223 }
 224
 225
 226
 227
 228 void SAL_CALL PresenterPreviewCache::addPreviewCreationNotifyListener (
 229     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 230     throw (css::uno::RuntimeException)
 231 {
 232     if (rBHelper.bDisposed || rBHelper.bInDispose)
 233         return;
 234     if (rxListener.is())
 235         mpCacheContext->AddPreviewCreationNotifyListener(rxListener);
 236 }
 237
 238
 239
 240
 241 void SAL_CALL PresenterPreviewCache::removePreviewCreationNotifyListener (
 242     const css::uno::Reference<css::drawing::XSlidePreviewCacheListener>& rxListener)
 243     throw (css::uno::RuntimeException)
 244 {
 245     ThrowIfDisposed();
 246     mpCacheContext->RemovePreviewCreationNotifyListener(rxListener);
 247 }
 248
 249
 250
 251
 252 void SAL_CALL PresenterPreviewCache::pause (void)
 253     throw (css::uno::RuntimeException)
 254 {
 255     ThrowIfDisposed();
 256     OSL_ASSERT(mpCache.get()!=NULL);
 257     mpCache->Pause();
 258 }
 259
 260
 261
 262
 263 void SAL_CALL PresenterPreviewCache::resume (void)
 264     throw (css::uno::RuntimeException)
 265 {
 266     ThrowIfDisposed();
 267     OSL_ASSERT(mpCache.get()!=NULL);
 268     mpCache->Resume();
 269 }
 270
 271
 272
 273
 274 //-----------------------------------------------------------------------------
 275
 276 void PresenterPreviewCache::ThrowIfDisposed (void)
 277     throw (::com::sun::star::lang::DisposedException)
 278 {
 279     if (rBHelper.bDisposed || rBHelper.bInDispose)
 280     {
 281         throw lang::DisposedException (
 282             ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 283                 "PresenterPreviewCache object has already been disposed")),
 284             static_cast<uno::XWeak*>(this));
 285     }
 286 }
 287
 288
 289
 290
 291 //===== PresenterPreviewCache::PresenterCacheContext ==========================
 292
 293
 294 PresenterPreviewCache::PresenterCacheContext::PresenterCacheContext (void)
 295     : mxSlides(),
 296       mxDocument(),
 297       mnFirstVisibleSlideIndex(-1),
 298       mnLastVisibleSlideIndex(-1),
 299       maListeners()
 300 {
 301 }
 302
 303
 304
 305
 306 PresenterPreviewCache::PresenterCacheContext::~PresenterCacheContext (void)
 307 {
 308 }
 309
 310
 311
 312
 313 void PresenterPreviewCache::PresenterCacheContext::SetDocumentSlides (
 314     const Reference<container::XIndexAccess>& rxSlides,
 315     const Reference<XInterface>& rxDocument)
 316 {
 317     mxSlides = rxSlides;
 318     mxDocument = rxDocument;
 319     mnFirstVisibleSlideIndex = -1;
 320     mnLastVisibleSlideIndex = -1;
 321 }
 322
 323
 324
 325
 326 void PresenterPreviewCache::PresenterCacheContext::SetVisibleSlideRange (
 327     const sal_Int32 nFirstVisibleSlideIndex,
 328     const sal_Int32 nLastVisibleSlideIndex)
 329 {
 330     if (nFirstVisibleSlideIndex > nLastVisibleSlideIndex || nFirstVisibleSlideIndex<0)
 331     {
 332         mnFirstVisibleSlideIndex = -1;
 333         mnLastVisibleSlideIndex = -1;
 334     }
 335     else
 336     {
 337         mnFirstVisibleSlideIndex = nFirstVisibleSlideIndex;
 338         mnLastVisibleSlideIndex = nLastVisibleSlideIndex;
 339     }
 340     if (mxSlides.is() && mnLastVisibleSlideIndex >= mxSlides->getCount())
 341         mnLastVisibleSlideIndex = mxSlides->getCount() - 1;
 342 }
 343
 344
 345
 346
 347 void PresenterPreviewCache::PresenterCacheContext::AddPreviewCreationNotifyListener (
 348     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 349 {
 350     maListeners.push_back(rxListener);
 351 }
 352
 353
 354
 355
 356 void PresenterPreviewCache::PresenterCacheContext::RemovePreviewCreationNotifyListener (
 357     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 358 {
 359     ListenerContainer::iterator iListener;
 360     for (iListener=maListeners.begin(); iListener!=maListeners.end(); ++iListener)
 361         if (*iListener == rxListener)
 362         {
 363             maListeners.erase(iListener);
 364             return;
 365         }
 366 }
 367
 368
 369
 370
 371 //----- CacheContext ----------------------------------------------------------
 372
 373 void PresenterPreviewCache::PresenterCacheContext::NotifyPreviewCreation (
 374     CacheKey aKey,
 375     const ::boost::shared_ptr<BitmapEx>& rPreview)
 376 {
 377     (void)rPreview;
 378
 379     if ( ! mxSlides.is())
 380         return;
 381     const sal_Int32 nCount(mxSlides->getCount());
 382     for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
 383         if (aKey == GetPage(nIndex))
 384             CallListeners(nIndex);
 385 }
 386
 387
 388
 389
 390 bool PresenterPreviewCache::PresenterCacheContext::IsIdle (void)
 391 {
 392     return true;
 393     /*
 394     sal_Int32 nIdleState (tools::IdleDetection::GetIdleState(NULL));
 395     if (nIdleState == tools::IdleDetection::IDET_IDLE)
 396         return true;
 397     else
 398         return false;
 399     */
 400 }
 401
 402
 403
 404
 405 bool PresenterPreviewCache::PresenterCacheContext::IsVisible (CacheKey aKey)
 406 {
 407     if (mnFirstVisibleSlideIndex < 0)
 408         return false;
 409     for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
 410     {
 411         const SdrPage* pPage = GetPage(nIndex);
 412         if (pPage == static_cast<const SdrPage*>(aKey))
 413             return true;
 414     }
 415     return false;
 416 }
 417
 418
 419
 420
 421 const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (CacheKey aKey)
 422 {
 423     return static_cast<const SdrPage*>(aKey);
 424 }
 425
 426
 427
 428
 429 ::boost::shared_ptr<std::vector<CacheKey> >
 430     PresenterPreviewCache::PresenterCacheContext::GetEntryList (bool bVisible)
 431 {
 432     ::boost::shared_ptr<std::vector<CacheKey> > pKeys (new std::vector<CacheKey>());
 433
 434     if ( ! mxSlides.is())
 435         return pKeys;
 436
 437     const sal_Int32 nFirstIndex (bVisible ? mnFirstVisibleSlideIndex : 0);
 438     const sal_Int32 nLastIndex (bVisible ? mnLastVisibleSlideIndex : mxSlides->getCount()-1);
 439
 440     if (nFirstIndex < 0)
 441         return pKeys;
 442
 443     for (sal_Int32 nIndex=nFirstIndex; nIndex<=nLastIndex; ++nIndex)
 444     {
 445         pKeys->push_back(GetPage(nIndex));
 446     }
 447
 448     return pKeys;
 449 }
 450
 451
 452
 453
 454 sal_Int32 PresenterPreviewCache::PresenterCacheContext::GetPriority (CacheKey aKey)
 455 {
 456     if ( ! mxSlides.is())
 457         return 0;
 458
 459     const sal_Int32 nCount (mxSlides->getCount());
 460
 461     for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
 462         if (aKey == GetPage(nIndex))
 463             return -nCount-1+nIndex;
 464
 465     for (sal_Int32 nIndex=0; nIndex<=nCount; ++nIndex)
 466         if (aKey == GetPage(nIndex))
 467             return nIndex;
 468
 469     return 0;
 470 }
 471
 472
 473
 474
 475 Reference<XInterface> PresenterPreviewCache::PresenterCacheContext::GetModel (void)
 476 {
 477     return mxDocument;
 478 }
 479
 480
 481
 482
 483 //-----------------------------------------------------------------------------
 484
 485 const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (
 486     const sal_Int32 nSlideIndex) const
 487 {
 488     if ( ! mxSlides.is())
 489         return NULL;
 490     if (nSlideIndex < 0 || nSlideIndex >= mxSlides->getCount())
 491         return NULL;
 492
 493     Reference<drawing::XDrawPage> xSlide (mxSlides->getByIndex(nSlideIndex), UNO_QUERY);
 494     const SdPage* pPage = SdPage::getImplementation(xSlide);
 495     return dynamic_cast<const SdrPage*>(pPage);
 496 }
 497
 498
 499
 500
 501 void PresenterPreviewCache::PresenterCacheContext::CallListeners (
 502     const sal_Int32 nIndex)
 503 {
 504     ListenerContainer aListeners (maListeners);
 505     ListenerContainer::const_iterator iListener;
 506     for (iListener=aListeners.begin(); iListener!=aListeners.end(); ++iListener)
 507     {
 508         try
 509         {
 510             (*iListener)->notifyPreviewCreation(nIndex);
 511         }
 512         catch (lang::DisposedException&)
 513         {
 514             RemovePreviewCreationNotifyListener(*iListener);
 515         }
 516     }
 517 }
 518
 519 } } // end of namespace ::sd::presenter