sd/source/ui/sidebar/MasterPageContainer.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 "MasterPageContainer.hxx"
  21
  22 #include "MasterPageContainerProviders.hxx"
  23 #include "MasterPageDescriptor.hxx"
  24 #include "MasterPageContainerFiller.hxx"
  25 #include "MasterPageContainerQueue.hxx"
  26 #include <TemplateScanner.hxx>
  27 #include <PreviewRenderer.hxx>
  28 #include <tools/AsynchronousTask.hxx>
  29 #include <tools/SdGlobalResourceContainer.hxx>
  30 #include <strings.hrc>
  31 #include <algorithm>
  32 #include <list>
  33 #include <memory>
  34 #include <set>
  35
  36 #include <unomodel.hxx>
  37 #include <com/sun/star/frame/Desktop.hpp>
  38 #include <com/sun/star/io/XStream.hpp>
  39 #include <com/sun/star/io/XInputStream.hpp>
  40 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  41 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  42 #include <com/sun/star/uno/Reference.hxx>
  43 #include <com/sun/star/uno/Any.hxx>
  44 #include <com/sun/star/util/XCloseable.hpp>
  45 #include <com/sun/star/util/CloseVetoException.hpp>
  46 #include <comphelper/processfactory.hxx>
  47 #include <sfx2/app.hxx>
  48 #include <svx/svdpage.hxx>
  49 #include <DrawDocShell.hxx>
  50 #include <drawdoc.hxx>
  51 #include <sdpage.hxx>
  52 #include <svl/itemset.hxx>
  53 #include <svl/eitem.hxx>
  54 #include <sdresid.hxx>
  55 #include <tools/TimerBasedTaskExecution.hxx>
  56 #include <pres.hxx>
  57 #include <osl/mutex.hxx>
  58 #include <osl/getglobalmutex.hxx>
  59 #include <xmloff/autolayout.hxx>
  60 #include <tools/debug.hxx>
  61
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::uno;
  64
  65 namespace {
  66
  67 typedef ::std::vector<sd::sidebar::SharedMasterPageDescriptor> MasterPageContainerType;
  68
  69 } // end of anonymous namespace
  70
  71 namespace sd { namespace sidebar {
  72
  73 /** Inner implementation class of the MasterPageContainer.
  74 */
  75 class MasterPageContainer::Implementation
  76     : public SdGlobalResource,
  77       public MasterPageContainerFiller::ContainerAdapter,
  78       public MasterPageContainerQueue::ContainerAdapter
  79 {
  80 public:
  81     mutable ::osl::Mutex maMutex;
  82
  83     static std::weak_ptr<Implementation> mpInstance;
  84     MasterPageContainerType maContainer;
  85
  86     static std::shared_ptr<Implementation> Instance();
  87
  88     void LateInit();
  89     void AddChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink);
  90     void RemoveChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink);
  91     void UpdatePreviewSizePixel();
  92     const Size& GetPreviewSizePixel (PreviewSize eSize) const;
  93
  94     bool HasToken (Token aToken) const;
  95     const SharedMasterPageDescriptor GetDescriptor (MasterPageContainer::Token aToken) const;
  96     SharedMasterPageDescriptor GetDescriptor (MasterPageContainer::Token aToken);
  97     virtual Token PutMasterPage (const SharedMasterPageDescriptor& rDescriptor) override;
  98     void InvalidatePreview (Token aToken);
  99     Image GetPreviewForToken (
 100         Token aToken,
 101         PreviewSize ePreviewSize);
 102     PreviewState GetPreviewState (Token aToken) const;
 103     bool RequestPreview (Token aToken);
 104
 105     Reference<frame::XModel> GetModel();
 106     SdDrawDocument* GetDocument();
 107
 108     void FireContainerChange (
 109         MasterPageContainerChangeEvent::EventType eType,
 110         Token aToken);
 111
 112     virtual bool UpdateDescriptor (
 113         const SharedMasterPageDescriptor& rpDescriptor,
 114         bool bForcePageObject,
 115         bool bForcePreview,
 116         bool bSendEvents) override;
 117
 118     void ReleaseDescriptor (Token aToken);
 119
 120     /** Called by the MasterPageContainerFiller to notify that all master
 121         pages from template documents have been added.
 122     */
 123     virtual void FillingDone() override;
 124
 125 private:
 126     Implementation();
 127     virtual ~Implementation() override;
 128
 129     class Deleter { public:
 130         void operator() (Implementation* pObject) { delete pObject; }
 131     };
 132     friend class Deleter;
 133
 134     enum InitializationState { NOT_INITIALIZED, INITIALIZING, INITIALIZED } meInitializationState;
 135
 136     std::unique_ptr<MasterPageContainerQueue> mpRequestQueue;
 137     css::uno::Reference<css::frame::XModel> mxModel;
 138     SdDrawDocument* mpDocument;
 139     PreviewRenderer maPreviewRenderer;
 140     /** Remember whether the first page object has already been used to
 141         determine the correct size ratio.
 142     */
 143     bool mbFirstPageObjectSeen;
 144
 145     // The widths for the previews contain two pixels for the border that is
 146     // painted around the preview.
 147     static const int SMALL_PREVIEW_WIDTH = 72 + 2;
 148     static const int LARGE_PREVIEW_WIDTH = 2*72 + 2;
 149
 150     /** This substition of page preview shows "Preparing preview" and is
 151         shown as long as the actual previews are not being present.
 152     */
 153     Image maLargePreviewBeingCreated;
 154     Image maSmallPreviewBeingCreated;
 155
 156     /** This substition of page preview is shown when a preview can not be
 157         created and thus is not available.
 158     */
 159     Image maLargePreviewNotAvailable;
 160     Image maSmallPreviewNotAvailable;
 161
 162     ::std::vector<Link<MasterPageContainerChangeEvent&,void>> maChangeListeners;
 163
 164     // We have to remember the tasks for initialization and filling in case
 165     // a MasterPageContainer object is destroyed before these tasks have
 166     // been completed.
 167     std::weak_ptr<sd::tools::TimerBasedTaskExecution> mpFillerTask;
 168
 169     Size maSmallPreviewSizePixel;
 170     Size maLargePreviewSizePixel;
 171
 172     Image GetPreviewSubstitution(const char* pId, PreviewSize ePreviewSize);
 173
 174     void CleanContainer();
 175 };
 176
 177 //===== MasterPageContainer ===================================================
 178
 179 std::weak_ptr<MasterPageContainer::Implementation>
 180     MasterPageContainer::Implementation::mpInstance;
 181
 182 std::shared_ptr<MasterPageContainer::Implementation>
 183     MasterPageContainer::Implementation::Instance()
 184 {
 185     std::shared_ptr<MasterPageContainer::Implementation> pInstance;
 186
 187     if (Implementation::mpInstance.expired())
 188     {
 189         ::osl::GetGlobalMutex aMutexFunctor;
 190         ::osl::MutexGuard aGuard (aMutexFunctor());
 191         if (Implementation::mpInstance.expired())
 192         {
 193             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 194             pInstance = std::shared_ptr<MasterPageContainer::Implementation>(
 195                 new MasterPageContainer::Implementation(),
 196                 MasterPageContainer::Implementation::Deleter());
 197             SdGlobalResourceContainer::Instance().AddResource(pInstance);
 198             Implementation::mpInstance = pInstance;
 199         }
 200         else
 201             pInstance = std::shared_ptr<MasterPageContainer::Implementation>(
 202                 Implementation::mpInstance);
 203     }
 204     else
 205     {
 206         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 207         pInstance = std::shared_ptr<MasterPageContainer::Implementation>(
 208             Implementation::mpInstance);
 209     }
 210
 211     DBG_ASSERT(pInstance != nullptr,
 212                "MasterPageContainer::Implementation::Instance(): instance is nullptr");
 213     return pInstance;
 214 }
 215
 216 MasterPageContainer::MasterPageContainer()
 217     : mpImpl(Implementation::Instance()),
 218       mePreviewSize(SMALL)
 219 {
 220     mpImpl->LateInit();
 221 }
 222
 223 MasterPageContainer::~MasterPageContainer()
 224 {
 225 }
 226
 227 void MasterPageContainer::AddChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink)
 228 {
 229     mpImpl->AddChangeListener(rLink);
 230 }
 231
 232 void MasterPageContainer::RemoveChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink)
 233 {
 234     mpImpl->RemoveChangeListener(rLink);
 235 }
 236
 237 void MasterPageContainer::SetPreviewSize (PreviewSize eSize)
 238 {
 239     mePreviewSize = eSize;
 240     mpImpl->FireContainerChange(
 241         MasterPageContainerChangeEvent::EventType::SIZE_CHANGED,
 242         NIL_TOKEN);
 243 }
 244
 245 Size const & MasterPageContainer::GetPreviewSizePixel() const
 246 {
 247     return mpImpl->GetPreviewSizePixel(mePreviewSize);
 248 }
 249
 250 MasterPageContainer::Token MasterPageContainer::PutMasterPage (
 251     const std::shared_ptr<MasterPageDescriptor>& rDescriptor)
 252 {
 253     return mpImpl->PutMasterPage(rDescriptor);
 254 }
 255
 256 void MasterPageContainer::AcquireToken (Token aToken)
 257 {
 258     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 259     if (pDescriptor.get() != nullptr)
 260     {
 261         ++pDescriptor->mnUseCount;
 262     }
 263 }
 264
 265 void MasterPageContainer::ReleaseToken (Token aToken)
 266 {
 267     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 268     if (pDescriptor.get() == nullptr)
 269         return;
 270
 271     OSL_ASSERT(pDescriptor->mnUseCount>0);
 272     --pDescriptor->mnUseCount;
 273     if (pDescriptor->mnUseCount > 0)
 274         return;
 275
 276     switch (pDescriptor->meOrigin)
 277     {
 278         case DEFAULT:
 279         case TEMPLATE:
 280         default:
 281             break;
 282
 283         case MASTERPAGE:
 284             mpImpl->ReleaseDescriptor(aToken);
 285             break;
 286     }
 287 }
 288
 289 int MasterPageContainer::GetTokenCount() const
 290 {
 291     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 292
 293     return mpImpl->maContainer.size();
 294 }
 295
 296 bool MasterPageContainer::HasToken (Token aToken) const
 297 {
 298     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 299
 300     return mpImpl->HasToken(aToken);
 301 }
 302
 303 MasterPageContainer::Token MasterPageContainer::GetTokenForIndex (int nIndex)
 304 {
 305     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 306
 307     Token aResult (NIL_TOKEN);
 308     if (HasToken(nIndex))
 309         aResult = mpImpl->maContainer[nIndex]->maToken;
 310     return aResult;
 311 }
 312
 313 MasterPageContainer::Token MasterPageContainer::GetTokenForURL (
 314     const OUString& sURL)
 315 {
 316     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 317
 318     Token aResult (NIL_TOKEN);
 319     if (!sURL.isEmpty())
 320     {
 321         MasterPageContainerType::iterator iEntry (
 322             ::std::find_if (
 323                 mpImpl->maContainer.begin(),
 324                 mpImpl->maContainer.end(),
 325                 MasterPageDescriptor::URLComparator(sURL)));
 326         if (iEntry != mpImpl->maContainer.end())
 327             aResult = (*iEntry)->maToken;
 328     }
 329     return aResult;
 330 }
 331
 332 MasterPageContainer::Token MasterPageContainer::GetTokenForStyleName (const OUString& sStyleName)
 333 {
 334     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 335
 336     Token aResult (NIL_TOKEN);
 337     if (!sStyleName.isEmpty())
 338     {
 339         MasterPageContainerType::iterator iEntry (
 340             ::std::find_if (
 341                 mpImpl->maContainer.begin(),
 342                 mpImpl->maContainer.end(),
 343                 MasterPageDescriptor::StyleNameComparator(sStyleName)));
 344         if (iEntry != mpImpl->maContainer.end())
 345             aResult = (*iEntry)->maToken;
 346     }
 347     return aResult;
 348 }
 349
 350 MasterPageContainer::Token MasterPageContainer::GetTokenForPageObject (
 351     const SdPage* pPage)
 352 {
 353     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 354
 355     Token aResult (NIL_TOKEN);
 356     if (pPage != nullptr)
 357     {
 358         MasterPageContainerType::iterator iEntry (
 359             ::std::find_if (
 360                 mpImpl->maContainer.begin(),
 361                 mpImpl->maContainer.end(),
 362                 MasterPageDescriptor::PageObjectComparator(pPage)));
 363         if (iEntry != mpImpl->maContainer.end())
 364             aResult = (*iEntry)->maToken;
 365     }
 366     return aResult;
 367 }
 368
 369 OUString MasterPageContainer::GetURLForToken (
 370     MasterPageContainer::Token aToken)
 371 {
 372     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 373
 374     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 375     if (pDescriptor.get() != nullptr)
 376         return pDescriptor->msURL;
 377     else
 378         return OUString();
 379 }
 380
 381 OUString MasterPageContainer::GetPageNameForToken (
 382     MasterPageContainer::Token aToken)
 383 {
 384     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 385
 386     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 387     if (pDescriptor.get() != nullptr)
 388         return pDescriptor->msPageName;
 389     else
 390         return OUString();
 391 }
 392
 393 OUString MasterPageContainer::GetStyleNameForToken (
 394     MasterPageContainer::Token aToken)
 395 {
 396     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 397
 398     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 399     if (pDescriptor.get() != nullptr)
 400         return pDescriptor->msStyleName;
 401     else
 402         return OUString();
 403 }
 404
 405 SdPage* MasterPageContainer::GetPageObjectForToken (
 406     MasterPageContainer::Token aToken,
 407     bool bLoad)
 408 {
 409     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 410
 411     SdPage* pPageObject = nullptr;
 412     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 413     if (pDescriptor.get() != nullptr)
 414     {
 415         pPageObject = pDescriptor->mpMasterPage;
 416         if (pPageObject == nullptr)
 417         {
 418             // The page object is not (yet) present.  Call
 419             // UpdateDescriptor() to trigger the PageObjectProvider() to
 420             // provide it.
 421             if (bLoad)
 422                 mpImpl->GetModel();
 423             if (mpImpl->UpdateDescriptor(pDescriptor,bLoad,false, true))
 424                 pPageObject = pDescriptor->mpMasterPage;
 425         }
 426     }
 427     return pPageObject;
 428 }
 429
 430 MasterPageContainer::Origin MasterPageContainer::GetOriginForToken (Token aToken)
 431 {
 432     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 433
 434     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 435     if (pDescriptor.get() != nullptr)
 436         return pDescriptor->meOrigin;
 437     else
 438         return UNKNOWN;
 439 }
 440
 441 sal_Int32 MasterPageContainer::GetTemplateIndexForToken (Token aToken)
 442 {
 443     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 444
 445     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 446     if (pDescriptor.get() != nullptr)
 447         return pDescriptor->mnTemplateIndex;
 448     else
 449         return -1;
 450 }
 451
 452 std::shared_ptr<MasterPageDescriptor> MasterPageContainer::GetDescriptorForToken (
 453     MasterPageContainer::Token aToken)
 454 {
 455     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 456
 457     return mpImpl->GetDescriptor(aToken);
 458 }
 459
 460 void MasterPageContainer::InvalidatePreview (MasterPageContainer::Token aToken)
 461 {
 462     mpImpl->InvalidatePreview(aToken);
 463 }
 464
 465 Image MasterPageContainer::GetPreviewForToken (MasterPageContainer::Token aToken)
 466 {
 467     return mpImpl->GetPreviewForToken(aToken,mePreviewSize);
 468 }
 469
 470 MasterPageContainer::PreviewState MasterPageContainer::GetPreviewState (Token aToken)
 471 {
 472     return mpImpl->GetPreviewState(aToken);
 473 }
 474
 475 bool MasterPageContainer::RequestPreview (Token aToken)
 476 {
 477     return mpImpl->RequestPreview(aToken);
 478 }
 479
 480 //==== Implementation ================================================
 481
 482 MasterPageContainer::Implementation::Implementation()
 483     : maMutex(),
 484       maContainer(),
 485       meInitializationState(NOT_INITIALIZED),
 486       mpDocument(nullptr),
 487       maPreviewRenderer(),
 488       mbFirstPageObjectSeen(false),
 489       maLargePreviewBeingCreated(),
 490       maSmallPreviewBeingCreated(),
 491       maLargePreviewNotAvailable(),
 492       maSmallPreviewNotAvailable(),
 493       maChangeListeners(),
 494       maSmallPreviewSizePixel(),
 495       maLargePreviewSizePixel()
 496 {
 497     UpdatePreviewSizePixel();
 498 }
 499
 500 MasterPageContainer::Implementation::~Implementation()
 501 {
 502     // When the initializer or filler tasks are still running then we have
 503     // to stop them now in order to prevent them from calling us back.
 504     tools::TimerBasedTaskExecution::ReleaseTask(mpFillerTask);
 505
 506     mpRequestQueue.reset();
 507
 508     uno::Reference<util::XCloseable> xCloseable (mxModel, uno::UNO_QUERY);
 509     if (xCloseable.is())
 510     {
 511         try
 512         {
 513             xCloseable->close(true);
 514         }
 515         catch (const css::util::CloseVetoException&)
 516         {
 517         }
 518     }
 519     mxModel = nullptr;
 520 }
 521
 522 void MasterPageContainer::Implementation::LateInit()
 523 {
 524     const ::osl::MutexGuard aGuard (maMutex);
 525
 526     if (meInitializationState != NOT_INITIALIZED)
 527         return;
 528
 529     meInitializationState = INITIALIZING;
 530
 531     OSL_ASSERT(Instance().get()==this);
 532     mpRequestQueue.reset(MasterPageContainerQueue::Create(
 533         std::shared_ptr<MasterPageContainerQueue::ContainerAdapter>(Instance())));
 534
 535     mpFillerTask = ::sd::tools::TimerBasedTaskExecution::Create(
 536         std::shared_ptr<tools::AsynchronousTask>(new MasterPageContainerFiller(*this)),
 537         5,
 538         50);
 539
 540     meInitializationState = INITIALIZED;
 541 }
 542
 543 void MasterPageContainer::Implementation::AddChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink)
 544 {
 545     const ::osl::MutexGuard aGuard (maMutex);
 546
 547     ::std::vector<Link<MasterPageContainerChangeEvent&,void>>::iterator iListener (
 548         ::std::find(maChangeListeners.begin(),maChangeListeners.end(),rLink));
 549     if (iListener == maChangeListeners.end())
 550         maChangeListeners.push_back(rLink);
 551
 552 }
 553
 554 void MasterPageContainer::Implementation::RemoveChangeListener (const Link<MasterPageContainerChangeEvent&,void>& rLink)
 555 {
 556     const ::osl::MutexGuard aGuard (maMutex);
 557
 558     ::std::vector<Link<MasterPageContainerChangeEvent&,void>>::iterator iListener (
 559         ::std::find(maChangeListeners.begin(),maChangeListeners.end(),rLink));
 560     if (iListener != maChangeListeners.end())
 561         maChangeListeners.erase(iListener);
 562 }
 563
 564 void MasterPageContainer::Implementation::UpdatePreviewSizePixel()
 565 {
 566     const ::osl::MutexGuard aGuard (maMutex);
 567
 568     // The default aspect ratio is 4:3
 569     int nWidth (4);
 570     int nHeight (3);
 571
 572     // Search for the first entry with an existing master page.
 573     auto iDescriptor = std::find_if(maContainer.begin(), maContainer.end(),
 574         [](const SharedMasterPageDescriptor& rxDescriptor) {
 575             return rxDescriptor != nullptr && rxDescriptor->mpMasterPage != nullptr;
 576         });
 577     if (iDescriptor != maContainer.end())
 578     {
 579         Size aPageSize ((*iDescriptor)->mpMasterPage->GetSize());
 580         OSL_ASSERT(aPageSize.Width() > 0 && aPageSize.Height() > 0);
 581         if (aPageSize.Width() > 0)
 582             nWidth = aPageSize.Width();
 583         if (aPageSize.Height() > 0)
 584             nHeight = aPageSize.Height();
 585         mbFirstPageObjectSeen = true;
 586     }
 587
 588     maSmallPreviewSizePixel.setWidth( SMALL_PREVIEW_WIDTH );
 589     maLargePreviewSizePixel.setWidth( LARGE_PREVIEW_WIDTH );
 590
 591     int nNewSmallHeight ((maSmallPreviewSizePixel.Width()-2) * nHeight / nWidth + 2);
 592     int nNewLargeHeight ((maLargePreviewSizePixel.Width()-2) * nHeight / nWidth + 2);
 593
 594     if (nNewSmallHeight!=maSmallPreviewSizePixel.Height()
 595         || nNewLargeHeight!=maLargePreviewSizePixel.Height())
 596     {
 597         maSmallPreviewSizePixel.setHeight( nNewSmallHeight );
 598         maLargePreviewSizePixel.setHeight( nNewLargeHeight );
 599         FireContainerChange(
 600             MasterPageContainerChangeEvent::EventType::SIZE_CHANGED,
 601             NIL_TOKEN);
 602     }
 603 }
 604
 605 const Size& MasterPageContainer::Implementation::GetPreviewSizePixel (PreviewSize eSize) const
 606 {
 607     if (eSize == SMALL)
 608         return maSmallPreviewSizePixel;
 609     else
 610         return maLargePreviewSizePixel;
 611 }
 612
 613 MasterPageContainer::Token MasterPageContainer::Implementation::PutMasterPage (
 614     const SharedMasterPageDescriptor& rpDescriptor)
 615 {
 616     const ::osl::MutexGuard aGuard (maMutex);
 617
 618     Token aResult (NIL_TOKEN);
 619
 620     // Get page object and preview when that is inexpensive.
 621     UpdateDescriptor(rpDescriptor,false,false, false);
 622
 623     // Look up the new MasterPageDescriptor and either insert it or update
 624     // an already existing one.
 625     MasterPageContainerType::iterator aEntry (
 626         ::std::find_if (
 627             maContainer.begin(),
 628             maContainer.end(),
 629             MasterPageDescriptor::AllComparator(rpDescriptor)));
 630     if (aEntry == maContainer.end())
 631     {
 632         // Insert a new MasterPageDescriptor.
 633         bool bIgnore(rpDescriptor->mpPageObjectProvider == nullptr
 634                      && rpDescriptor->msURL.isEmpty());
 635
 636         if ( ! bIgnore)
 637         {
 638             CleanContainer();
 639
 640             aResult = maContainer.size();
 641             rpDescriptor->SetToken(aResult);
 642
 643             // Templates are precious, i.e. we lock them so that they will
 644             // not be destroyed when (temporarily) no one references them.
 645             // They will only be deleted when the container is destroyed.
 646             switch (rpDescriptor->meOrigin)
 647             {
 648                 case TEMPLATE:
 649                 case DEFAULT:
 650                     ++rpDescriptor->mnUseCount;
 651                     break;
 652
 653                 default:
 654                     break;
 655             }
 656
 657             maContainer.push_back(rpDescriptor);
 658             aEntry = maContainer.end()-1;
 659
 660             FireContainerChange(MasterPageContainerChangeEvent::EventType::CHILD_ADDED,aResult);
 661         }
 662     }
 663     else
 664     {
 665         // Update an existing MasterPageDescriptor.
 666         aResult = (*aEntry)->maToken;
 667         std::unique_ptr<std::vector<MasterPageContainerChangeEvent::EventType> > pEventTypes(
 668             (*aEntry)->Update(*rpDescriptor));
 669         if (pEventTypes != nullptr && !pEventTypes->empty())
 670         {
 671             // One or more aspects of the descriptor have changed.  Send
 672             // appropriate events to the listeners.
 673             UpdateDescriptor(*aEntry,false,false, true);
 674
 675             for (auto& rEventType : *pEventTypes)
 676             {
 677                 FireContainerChange(rEventType, (*aEntry)->maToken);
 678             }
 679         }
 680     }
 681
 682     return aResult;
 683 }
 684
 685 bool MasterPageContainer::Implementation::HasToken (Token aToken) const
 686 {
 687     return aToken>=0
 688         && static_cast<unsigned>(aToken)<maContainer.size()
 689         && maContainer[aToken].get()!=nullptr;
 690 }
 691
 692 const SharedMasterPageDescriptor MasterPageContainer::Implementation::GetDescriptor (
 693     Token aToken) const
 694 {
 695     if (aToken>=0 && static_cast<unsigned>(aToken)<maContainer.size())
 696         return maContainer[aToken];
 697     else
 698         return SharedMasterPageDescriptor();
 699 }
 700
 701 SharedMasterPageDescriptor MasterPageContainer::Implementation::GetDescriptor (Token aToken)
 702 {
 703     if (aToken>=0 && static_cast<unsigned>(aToken)<maContainer.size())
 704         return maContainer[aToken];
 705     else
 706         return SharedMasterPageDescriptor();
 707 }
 708
 709 void MasterPageContainer::Implementation::InvalidatePreview (Token aToken)
 710 {
 711     const ::osl::MutexGuard aGuard (maMutex);
 712
 713     SharedMasterPageDescriptor pDescriptor (GetDescriptor(aToken));
 714     if (pDescriptor.get() != nullptr)
 715     {
 716         pDescriptor->maSmallPreview = Image();
 717         pDescriptor->maLargePreview = Image();
 718         RequestPreview(aToken);
 719     }
 720 }
 721
 722 Image MasterPageContainer::Implementation::GetPreviewForToken (
 723     MasterPageContainer::Token aToken,
 724     PreviewSize ePreviewSize)
 725 {
 726     const ::osl::MutexGuard aGuard (maMutex);
 727
 728     Image aPreview;
 729     PreviewState ePreviewState (GetPreviewState(aToken));
 730
 731     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 732
 733     // When the preview is missing but inexpensively creatable then do that
 734     // now.
 735     if (pDescriptor.get()!=nullptr)
 736     {
 737         if (ePreviewState == PS_CREATABLE)
 738             if (UpdateDescriptor(pDescriptor, false,false, true))
 739                 if (pDescriptor->maLargePreview.GetSizePixel().Width() != 0)
 740                     ePreviewState = PS_AVAILABLE;
 741
 742         switch (ePreviewState)
 743         {
 744             case PS_AVAILABLE:
 745                 aPreview = pDescriptor->GetPreview(ePreviewSize);
 746                 break;
 747
 748             case PS_PREPARING:
 749                 aPreview = GetPreviewSubstitution(
 750                     STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION,
 751                     ePreviewSize);
 752                 break;
 753
 754             case PS_CREATABLE:
 755                 aPreview = GetPreviewSubstitution(
 756                     STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION,
 757                     ePreviewSize);
 758                 break;
 759
 760             case PS_NOT_AVAILABLE:
 761                 aPreview = GetPreviewSubstitution(
 762                     STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION,
 763                     ePreviewSize);
 764                 if (ePreviewSize == SMALL)
 765                     pDescriptor->maSmallPreview = aPreview;
 766                 else
 767                     pDescriptor->maLargePreview = aPreview;
 768                 break;
 769         }
 770     }
 771
 772     return aPreview;
 773 }
 774
 775 MasterPageContainer::PreviewState MasterPageContainer::Implementation::GetPreviewState (
 776     Token aToken) const
 777 {
 778     const ::osl::MutexGuard aGuard (maMutex);
 779
 780     PreviewState eState (PS_NOT_AVAILABLE);
 781
 782     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 783     if (pDescriptor.get() != nullptr)
 784     {
 785         if (pDescriptor->maLargePreview.GetSizePixel().Width() != 0)
 786             eState = PS_AVAILABLE;
 787         else if (pDescriptor->mpPreviewProvider != nullptr)
 788         {
 789             // The preview does not exist but can be created.  When that is
 790             // not expensive then do it at once.
 791             if (mpRequestQueue->HasRequest(aToken))
 792                 eState = PS_PREPARING;
 793             else
 794                 eState = PS_CREATABLE;
 795         }
 796         else
 797             eState = PS_NOT_AVAILABLE;
 798     }
 799
 800     return eState;
 801 }
 802
 803 bool MasterPageContainer::Implementation::RequestPreview (Token aToken)
 804 {
 805     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 806     if (pDescriptor.get() != nullptr)
 807         return mpRequestQueue->RequestPreview(pDescriptor);
 808     else
 809         return false;
 810 }
 811
 812 Reference<frame::XModel> MasterPageContainer::Implementation::GetModel()
 813 {
 814     const ::osl::MutexGuard aGuard (maMutex);
 815
 816     if ( ! mxModel.is())
 817     {
 818         // Get the desktop a s service factory.
 819         uno::Reference<frame::XDesktop2> xDesktop  = frame::Desktop::create(
 820             ::comphelper::getProcessComponentContext() );
 821
 822         // Create a new model.
 823         mxModel.set(
 824             ::comphelper::getProcessServiceFactory()->createInstance(
 825                 "com.sun.star.presentation.PresentationDocument"),
 826             uno::UNO_QUERY);
 827
 828         // Initialize the model.
 829         uno::Reference<frame::XLoadable> xLoadable (mxModel,uno::UNO_QUERY);
 830         if (xLoadable.is())
 831             xLoadable->initNew();
 832
 833         // Use its tunnel to get a pointer to its core implementation.
 834         uno::Reference<lang::XUnoTunnel> xUnoTunnel (mxModel, uno::UNO_QUERY);
 835         if (xUnoTunnel.is())
 836         {
 837             mpDocument = reinterpret_cast<SdXImpressDocument*>(
 838                 xUnoTunnel->getSomething(
 839                     SdXImpressDocument::getUnoTunnelId()))->GetDoc();
 840         }
 841
 842         // Create a default page.
 843         uno::Reference<drawing::XDrawPagesSupplier> xSlideSupplier (mxModel, uno::UNO_QUERY);
 844         if (xSlideSupplier.is())
 845         {
 846             uno::Reference<drawing::XDrawPages> xSlides (
 847                 xSlideSupplier->getDrawPages(), uno::UNO_QUERY);
 848             if (xSlides.is())
 849             {
 850                 uno::Reference<drawing::XDrawPage> xNewPage (xSlides->insertNewByIndex(0));
 851                 uno::Reference<beans::XPropertySet> xProperties(xNewPage, uno::UNO_QUERY);
 852                 if (xProperties.is())
 853                     xProperties->setPropertyValue(
 854                         "Layout",
 855                         makeAny(sal_Int16(AUTOLAYOUT_TITLE)));
 856             }
 857         }
 858     }
 859     return mxModel;
 860 }
 861
 862 SdDrawDocument* MasterPageContainer::Implementation::GetDocument()
 863 {
 864     GetModel();
 865     return mpDocument;
 866 }
 867
 868 Image MasterPageContainer::Implementation::GetPreviewSubstitution (
 869     const char* pId,
 870     PreviewSize ePreviewSize)
 871 {
 872     const ::osl::MutexGuard aGuard (maMutex);
 873
 874     Image aPreview;
 875
 876     if (strcmp(pId, STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION) == 0)
 877     {
 878         Image& rPreview (ePreviewSize==SMALL
 879             ? maSmallPreviewBeingCreated
 880             : maLargePreviewBeingCreated);
 881         if (rPreview.GetSizePixel().Width() == 0)
 882         {
 883             rPreview = maPreviewRenderer.RenderSubstitution(
 884                 ePreviewSize==SMALL ? maSmallPreviewSizePixel : maLargePreviewSizePixel,
 885                 SdResId(STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION));
 886         }
 887         aPreview = rPreview;
 888     }
 889     else if (strcmp(pId, STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION) == 0)
 890     {
 891         Image& rPreview (ePreviewSize==SMALL
 892             ? maSmallPreviewNotAvailable
 893             : maLargePreviewNotAvailable);
 894         if (rPreview.GetSizePixel().Width() == 0)
 895         {
 896             rPreview = maPreviewRenderer.RenderSubstitution(
 897                 ePreviewSize==SMALL ? maSmallPreviewSizePixel : maLargePreviewSizePixel,
 898                 SdResId(STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION));
 899         }
 900         aPreview = rPreview;
 901     }
 902
 903     return aPreview;
 904 }
 905
 906 void MasterPageContainer::Implementation::CleanContainer()
 907 {
 908     // Remove the empty elements at the end of the container.  The empty
 909     // elements in the middle can not be removed because that would
 910     // invalidate the references still held by others.
 911     int nIndex (maContainer.size()-1);
 912     while (nIndex>=0 && maContainer[nIndex].get()==nullptr)
 913         --nIndex;
 914     maContainer.resize(++nIndex);
 915 }
 916
 917 void MasterPageContainer::Implementation::FireContainerChange (
 918     MasterPageContainerChangeEvent::EventType eType,
 919     Token aToken)
 920 {
 921     ::std::vector<Link<MasterPageContainerChangeEvent&,void>> aCopy(maChangeListeners);
 922     MasterPageContainerChangeEvent aEvent;
 923     aEvent.meEventType = eType;
 924     aEvent.maChildToken = aToken;
 925     for (auto& rListener : aCopy)
 926         rListener.Call(aEvent);
 927 }
 928
 929 bool MasterPageContainer::Implementation::UpdateDescriptor (
 930     const SharedMasterPageDescriptor& rpDescriptor,
 931     bool bForcePageObject,
 932     bool bForcePreview,
 933     bool bSendEvents)
 934 {
 935     const ::osl::MutexGuard aGuard (maMutex);
 936
 937     // We have to create the page object when the preview provider needs it
 938     // and the caller needs the preview.
 939     bForcePageObject |= (bForcePreview
 940         && rpDescriptor->mpPreviewProvider->NeedsPageObject()
 941         && rpDescriptor->mpMasterPage==nullptr);
 942
 943     // Define a cost threshold so that an update or page object or preview
 944     // that is at least this cost are made at once. Updates with higher cost
 945     // are scheduled for later.
 946     sal_Int32 nCostThreshold (mpRequestQueue->IsEmpty() ? 5 : 0);
 947
 948     // Update the page object (which may be used for the preview update).
 949     if (bForcePageObject)
 950         GetDocument();
 951     int nPageObjectModified (rpDescriptor->UpdatePageObject(
 952         (bForcePageObject ? -1 : nCostThreshold),
 953         mpDocument));
 954     if (nPageObjectModified == 1 && bSendEvents)
 955         FireContainerChange(
 956             MasterPageContainerChangeEvent::EventType::DATA_CHANGED,
 957             rpDescriptor->maToken);
 958     if (nPageObjectModified == -1 && bSendEvents)
 959         FireContainerChange(
 960             MasterPageContainerChangeEvent::EventType::CHILD_REMOVED,
 961             rpDescriptor->maToken);
 962     if (nPageObjectModified && ! mbFirstPageObjectSeen)
 963         UpdatePreviewSizePixel();
 964
 965     // Update the preview.
 966     bool bPreviewModified (rpDescriptor->UpdatePreview(
 967         (bForcePreview ? -1 : nCostThreshold),
 968         maSmallPreviewSizePixel,
 969         maLargePreviewSizePixel,
 970         maPreviewRenderer));
 971
 972     if (bPreviewModified && bSendEvents)
 973         FireContainerChange(
 974             MasterPageContainerChangeEvent::EventType::PREVIEW_CHANGED,
 975             rpDescriptor->maToken);
 976
 977     return nPageObjectModified || bPreviewModified;
 978 }
 979
 980 void MasterPageContainer::Implementation::ReleaseDescriptor (Token aToken)
 981 {
 982     if (aToken>=0 && static_cast<unsigned>(aToken)<maContainer.size())
 983     {
 984         maContainer[aToken].reset();
 985     }
 986 }
 987
 988 void MasterPageContainer::Implementation::FillingDone()
 989 {
 990     mpRequestQueue->ProcessAllRequests();
 991 }
 992
 993 } } // end of namespace sd::sidebar
 994
 995 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */