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