sd/source/ui/presenter/PresenterPreviewCache.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 "PresenterPreviewCache.hxx"
  21 #include "facreg.hxx"
  22
  23 #include "cache/SlsCacheContext.hxx"
  24 #include "tools/IdleDetection.hxx"
  25 #include "sdpage.hxx"
  26 #include <cppcanvas/vclfactory.hxx>
  27 #include <com/sun/star/drawing/XDrawPage.hpp>
  28
  29 using namespace ::com::sun::star;
  30 using namespace ::com::sun::star::uno;
  31 using namespace ::sd::slidesorter::cache;
  32
  33 namespace sd { namespace presenter {
  34
  35 class PresenterPreviewCache::PresenterCacheContext : public CacheContext
  36 {
  37 public:
  38     PresenterCacheContext();
  39     virtual ~PresenterCacheContext();
  40
  41     void SetDocumentSlides (
  42         const Reference<container::XIndexAccess>& rxSlides,
  43         const Reference<XInterface>& rxDocument);
  44     void SetVisibleSlideRange (
  45         const sal_Int32 nFirstVisibleSlideIndex,
  46         const sal_Int32 nLastVisibleSlideIndex);
  47     const SdrPage* GetPage (const sal_Int32 nSlideIndex) const;
  48     void AddPreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
  49     void RemovePreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
  50
  51     // CacheContext
  52     virtual void NotifyPreviewCreation (
  53         CacheKey aKey,
  54         const Bitmap& rPreview) SAL_OVERRIDE;
  55     virtual bool IsIdle() SAL_OVERRIDE;
  56     virtual bool IsVisible (CacheKey aKey) SAL_OVERRIDE;
  57     virtual const SdrPage* GetPage (CacheKey aKey) SAL_OVERRIDE;
  58     virtual ::boost::shared_ptr<std::vector<CacheKey> > GetEntryList (bool bVisible) SAL_OVERRIDE;
  59     virtual sal_Int32 GetPriority (CacheKey aKey) SAL_OVERRIDE;
  60     virtual ::com::sun::star::uno::Reference<com::sun::star::uno::XInterface> GetModel() SAL_OVERRIDE;
  61
  62 private:
  63     Reference<container::XIndexAccess> mxSlides;
  64     Reference<XInterface> mxDocument;
  65     sal_Int32 mnFirstVisibleSlideIndex;
  66     sal_Int32 mnLastVisibleSlideIndex;
  67     typedef ::std::vector<css::uno::Reference<css::drawing::XSlidePreviewCacheListener> > ListenerContainer;
  68     ListenerContainer maListeners;
  69
  70     void CallListeners (const sal_Int32 nSlideIndex);
  71 };
  72
  73 //===== PresenterPreviewCache =================================================
  74
  75 PresenterPreviewCache::PresenterPreviewCache (const Reference<XComponentContext>& rxContext)
  76     : PresenterPreviewCacheInterfaceBase(m_aMutex),
  77       maPreviewSize(Size(200,200)),
  78       mpCacheContext(new PresenterCacheContext()),
  79       mpCache(new PageCache(maPreviewSize, Bitmap::HasFastScale(), mpCacheContext))
  80 {
  81     (void)rxContext;
  82 }
  83
  84 PresenterPreviewCache::~PresenterPreviewCache()
  85 {
  86 }
  87
  88 //----- XInitialize -----------------------------------------------------------
  89
  90 void SAL_CALL PresenterPreviewCache::initialize (const Sequence<Any>& rArguments)
  91     throw(Exception, RuntimeException, std::exception)
  92 {
  93     if (rArguments.getLength() != 0)
  94         throw RuntimeException();
  95 }
  96
  97 //----- XSlidePreviewCache ----------------------------------------------------
  98
  99 void SAL_CALL PresenterPreviewCache::setDocumentSlides (
 100     const Reference<container::XIndexAccess>& rxSlides,
 101     const Reference<XInterface>& rxDocument)
 102     throw (RuntimeException, std::exception)
 103 {
 104     ThrowIfDisposed();
 105     OSL_ASSERT(mpCacheContext.get()!=NULL);
 106
 107     mpCacheContext->SetDocumentSlides(rxSlides, rxDocument);
 108 }
 109
 110 void SAL_CALL PresenterPreviewCache::setVisibleRange (
 111     sal_Int32 nFirstVisibleSlideIndex,
 112     sal_Int32 nLastVisibleSlideIndex)
 113     throw (css::uno::RuntimeException, std::exception)
 114 {
 115     ThrowIfDisposed();
 116     OSL_ASSERT(mpCacheContext.get()!=NULL);
 117
 118     mpCacheContext->SetVisibleSlideRange (nFirstVisibleSlideIndex, nLastVisibleSlideIndex);
 119 }
 120
 121 void SAL_CALL PresenterPreviewCache::setPreviewSize (
 122     const css::geometry::IntegerSize2D& rSize)
 123     throw (css::uno::RuntimeException, std::exception)
 124 {
 125     ThrowIfDisposed();
 126     OSL_ASSERT(mpCache.get()!=NULL);
 127
 128     maPreviewSize = Size(rSize.Width, rSize.Height);
 129     mpCache->ChangeSize(maPreviewSize, Bitmap::HasFastScale());
 130 }
 131
 132 Reference<rendering::XBitmap> SAL_CALL PresenterPreviewCache::getSlidePreview (
 133     sal_Int32 nSlideIndex,
 134     const Reference<rendering::XCanvas>& rxCanvas)
 135     throw (css::uno::RuntimeException, std::exception)
 136 {
 137     ThrowIfDisposed();
 138     OSL_ASSERT(mpCacheContext.get()!=NULL);
 139
 140     cppcanvas::CanvasSharedPtr pCanvas (
 141         cppcanvas::VCLFactory::createCanvas(rxCanvas));
 142
 143     const SdrPage* pPage = mpCacheContext->GetPage(nSlideIndex);
 144     if (pPage == NULL)
 145         throw RuntimeException();
 146
 147     const BitmapEx aPreview (mpCache->GetPreviewBitmap(pPage,true));
 148     if (aPreview.IsEmpty())
 149         return NULL;
 150     else
 151         return cppcanvas::VCLFactory::createBitmap(
 152             pCanvas,
 153             aPreview)->getUNOBitmap();
 154 }
 155
 156 void SAL_CALL PresenterPreviewCache::addPreviewCreationNotifyListener (
 157     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 158     throw (css::uno::RuntimeException, std::exception)
 159 {
 160     if (rBHelper.bDisposed || rBHelper.bInDispose)
 161         return;
 162     if (rxListener.is())
 163         mpCacheContext->AddPreviewCreationNotifyListener(rxListener);
 164 }
 165
 166 void SAL_CALL PresenterPreviewCache::removePreviewCreationNotifyListener (
 167     const css::uno::Reference<css::drawing::XSlidePreviewCacheListener>& rxListener)
 168     throw (css::uno::RuntimeException, std::exception)
 169 {
 170     ThrowIfDisposed();
 171     mpCacheContext->RemovePreviewCreationNotifyListener(rxListener);
 172 }
 173
 174 void SAL_CALL PresenterPreviewCache::pause()
 175     throw (css::uno::RuntimeException, std::exception)
 176 {
 177     ThrowIfDisposed();
 178     OSL_ASSERT(mpCache.get()!=NULL);
 179     mpCache->Pause();
 180 }
 181
 182 void SAL_CALL PresenterPreviewCache::resume()
 183     throw (css::uno::RuntimeException, std::exception)
 184 {
 185     ThrowIfDisposed();
 186     OSL_ASSERT(mpCache.get()!=NULL);
 187     mpCache->Resume();
 188 }
 189
 190 void PresenterPreviewCache::ThrowIfDisposed()
 191     throw (::com::sun::star::lang::DisposedException)
 192 {
 193     if (rBHelper.bDisposed || rBHelper.bInDispose)
 194     {
 195         throw lang::DisposedException ("PresenterPreviewCache object has already been disposed",
 196             static_cast<uno::XWeak*>(this));
 197     }
 198 }
 199
 200 //===== PresenterPreviewCache::PresenterCacheContext ==========================
 201
 202 PresenterPreviewCache::PresenterCacheContext::PresenterCacheContext()
 203     : mxSlides(),
 204       mxDocument(),
 205       mnFirstVisibleSlideIndex(-1),
 206       mnLastVisibleSlideIndex(-1),
 207       maListeners()
 208 {
 209 }
 210
 211 PresenterPreviewCache::PresenterCacheContext::~PresenterCacheContext()
 212 {
 213 }
 214
 215 void PresenterPreviewCache::PresenterCacheContext::SetDocumentSlides (
 216     const Reference<container::XIndexAccess>& rxSlides,
 217     const Reference<XInterface>& rxDocument)
 218 {
 219     mxSlides = rxSlides;
 220     mxDocument = rxDocument;
 221     mnFirstVisibleSlideIndex = -1;
 222     mnLastVisibleSlideIndex = -1;
 223 }
 224
 225 void PresenterPreviewCache::PresenterCacheContext::SetVisibleSlideRange (
 226     const sal_Int32 nFirstVisibleSlideIndex,
 227     const sal_Int32 nLastVisibleSlideIndex)
 228 {
 229     if (nFirstVisibleSlideIndex > nLastVisibleSlideIndex || nFirstVisibleSlideIndex<0)
 230     {
 231         mnFirstVisibleSlideIndex = -1;
 232         mnLastVisibleSlideIndex = -1;
 233     }
 234     else
 235     {
 236         mnFirstVisibleSlideIndex = nFirstVisibleSlideIndex;
 237         mnLastVisibleSlideIndex = nLastVisibleSlideIndex;
 238     }
 239     if (mxSlides.is() && mnLastVisibleSlideIndex >= mxSlides->getCount())
 240         mnLastVisibleSlideIndex = mxSlides->getCount() - 1;
 241 }
 242
 243 void PresenterPreviewCache::PresenterCacheContext::AddPreviewCreationNotifyListener (
 244     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 245 {
 246     maListeners.push_back(rxListener);
 247 }
 248
 249 void PresenterPreviewCache::PresenterCacheContext::RemovePreviewCreationNotifyListener (
 250     const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
 251 {
 252     ListenerContainer::iterator iListener;
 253     for (iListener=maListeners.begin(); iListener!=maListeners.end(); ++iListener)
 254         if (*iListener == rxListener)
 255         {
 256             maListeners.erase(iListener);
 257             return;
 258         }
 259 }
 260
 261 //----- CacheContext ----------------------------------------------------------
 262
 263 void PresenterPreviewCache::PresenterCacheContext::NotifyPreviewCreation (
 264     CacheKey aKey,
 265     const Bitmap& rPreview)
 266 {
 267     (void)rPreview;
 268
 269     if ( ! mxSlides.is())
 270         return;
 271     const sal_Int32 nCount(mxSlides->getCount());
 272     for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
 273         if (aKey == GetPage(nIndex))
 274             CallListeners(nIndex);
 275 }
 276
 277 bool PresenterPreviewCache::PresenterCacheContext::IsIdle()
 278 {
 279     return true;
 280 }
 281
 282 bool PresenterPreviewCache::PresenterCacheContext::IsVisible (CacheKey aKey)
 283 {
 284     if (mnFirstVisibleSlideIndex < 0)
 285         return false;
 286     for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
 287     {
 288         const SdrPage* pPage = GetPage(nIndex);
 289         if (pPage == static_cast<const SdrPage*>(aKey))
 290             return true;
 291     }
 292     return false;
 293 }
 294
 295 const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (CacheKey aKey)
 296 {
 297     return static_cast<const SdrPage*>(aKey);
 298 }
 299
 300 ::boost::shared_ptr<std::vector<CacheKey> >
 301     PresenterPreviewCache::PresenterCacheContext::GetEntryList (bool bVisible)
 302 {
 303     ::boost::shared_ptr<std::vector<CacheKey> > pKeys (new std::vector<CacheKey>());
 304
 305     if ( ! mxSlides.is())
 306         return pKeys;
 307
 308     const sal_Int32 nFirstIndex (bVisible ? mnFirstVisibleSlideIndex : 0);
 309     const sal_Int32 nLastIndex (bVisible ? mnLastVisibleSlideIndex : mxSlides->getCount()-1);
 310
 311     if (nFirstIndex < 0)
 312         return pKeys;
 313
 314     for (sal_Int32 nIndex=nFirstIndex; nIndex<=nLastIndex; ++nIndex)
 315     {
 316         pKeys->push_back(GetPage(nIndex));
 317     }
 318
 319     return pKeys;
 320 }
 321
 322 sal_Int32 PresenterPreviewCache::PresenterCacheContext::GetPriority (CacheKey aKey)
 323 {
 324     if ( ! mxSlides.is())
 325         return 0;
 326
 327     const sal_Int32 nCount (mxSlides->getCount());
 328
 329     for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
 330         if (aKey == GetPage(nIndex))
 331             return -nCount-1+nIndex;
 332
 333     for (sal_Int32 nIndex=0; nIndex<=nCount; ++nIndex)
 334         if (aKey == GetPage(nIndex))
 335             return nIndex;
 336
 337     return 0;
 338 }
 339
 340 Reference<XInterface> PresenterPreviewCache::PresenterCacheContext::GetModel()
 341 {
 342     return mxDocument;
 343 }
 344
 345 const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (
 346     const sal_Int32 nSlideIndex) const
 347 {
 348     if ( ! mxSlides.is())
 349         return NULL;
 350     if (nSlideIndex < 0 || nSlideIndex >= mxSlides->getCount())
 351         return NULL;
 352
 353     Reference<drawing::XDrawPage> xSlide (mxSlides->getByIndex(nSlideIndex), UNO_QUERY);
 354     const SdPage* pPage = SdPage::getImplementation(xSlide);
 355     return dynamic_cast<const SdrPage*>(pPage);
 356 }
 357
 358 void PresenterPreviewCache::PresenterCacheContext::CallListeners (
 359     const sal_Int32 nIndex)
 360 {
 361     ListenerContainer aListeners (maListeners);
 362     ListenerContainer::const_iterator iListener;
 363     for (iListener=aListeners.begin(); iListener!=aListeners.end(); ++iListener)
 364     {
 365         try
 366         {
 367             (*iListener)->notifyPreviewCreation(nIndex);
 368         }
 369         catch (lang::DisposedException&)
 370         {
 371             RemovePreviewCreationNotifyListener(*iListener);
 372         }
 373     }
 374 }
 375
 376 } } // end of namespace ::sd::presenter
 377
 378
 379 extern "C" SAL_DLLPUBLIC_EXPORT ::com::sun::star::uno::XInterface* SAL_CALL
 380 com_sun_star_comp_Draw_PresenterPreviewCache_get_implementation(::com::sun::star::uno::XComponentContext* context,
 381                                                                 ::com::sun::star::uno::Sequence<css::uno::Any> const &)
 382 {
 383     return cppu::acquire(new sd::presenter::PresenterPreviewCache(context));
 384 }
 385
 386
 387
 388 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */