sd/source/ui/toolpanel/controls/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
  21 #include "MasterPageContainer.hxx"
  22
  23 #include "MasterPageDescriptor.hxx"
  24 #include "MasterPageContainerFiller.hxx"
  25 #include "MasterPageContainerQueue.hxx"
  26 #include "TemplateScanner.hxx"
  27 #include "tools/AsynchronousTask.hxx"
  28 #include "strings.hrc"
  29 #include <algorithm>
  30 #include <list>
  31 #include <set>
  32
  33 #include "unomodel.hxx"
  34 #include <com/sun/star/frame/Desktop.hpp>
  35 #include <com/sun/star/frame/XComponentLoader.hpp>
  36 #include <com/sun/star/io/XStream.hpp>
  37 #include <com/sun/star/io/XInputStream.hpp>
  38 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  39 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  40 #include <com/sun/star/uno/Reference.hxx>
  41 #include <com/sun/star/uno/Any.hxx>
  42 #include <com/sun/star/uno/Sequence.hxx>
  43 #include <com/sun/star/util/XCloseable.hpp>
  44 #include <comphelper/processfactory.hxx>
  45 #include <sfx2/app.hxx>
  46 #include <svx/svdpage.hxx>
  47 #include "DrawDocShell.hxx"
  48 #include "drawdoc.hxx"
  49 #include "sdpage.hxx"
  50 #include <svl/itemset.hxx>
  51 #include <svl/eitem.hxx>
  52 #include "sdresid.hxx"
  53 #include "tools/TimerBasedTaskExecution.hxx"
  54 #include "pres.hxx"
  55 #include <osl/mutex.hxx>
  56 #include <boost/weak_ptr.hpp>
  57
  58 using namespace ::com::sun::star;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::sd::toolpanel::controls;
  61
  62 namespace {
  63
  64 typedef ::std::vector<SharedMasterPageDescriptor> MasterPageContainerType;
  65
  66 } // end of anonymous namespace
  67
  68
  69 namespace sd { namespace toolpanel { namespace controls {
  70
  71
  72 /** Inner implementation class of the MasterPageContainer.
  73 */
  74 class MasterPageContainer::Implementation
  75     : public SdGlobalResource,
  76       public MasterPageContainerFiller::ContainerAdapter,
  77       public MasterPageContainerQueue::ContainerAdapter
  78 {
  79 public:
  80     mutable ::osl::Mutex maMutex;
  81
  82     static ::boost::weak_ptr<Implementation> mpInstance;
  83     MasterPageContainerType maContainer;
  84
  85     static ::boost::shared_ptr<Implementation> Instance (void);
  86
  87     void LateInit (void);
  88     void AddChangeListener (const Link& rLink);
  89     void RemoveChangeListener (const Link& rLink);
  90     void UpdatePreviewSizePixel (void);
  91     Size GetPreviewSizePixel (PreviewSize eSize) const;
  92
  93     bool HasToken (Token aToken) const;
  94     const SharedMasterPageDescriptor GetDescriptor (MasterPageContainer::Token aToken) const;
  95     SharedMasterPageDescriptor GetDescriptor (MasterPageContainer::Token aToken);
  96     virtual Token PutMasterPage (const SharedMasterPageDescriptor& rDescriptor);
  97     void InvalidatePreview (Token aToken);
  98     Image GetPreviewForToken (
  99         Token aToken,
 100         PreviewSize ePreviewSize);
 101     PreviewState GetPreviewState (Token aToken) const;
 102     bool RequestPreview (Token aToken);
 103
 104     Reference<frame::XModel> GetModel (void);
 105     SdDrawDocument* GetDocument (void);
 106
 107     void FireContainerChange (
 108         MasterPageContainerChangeEvent::EventType eType,
 109         Token aToken,
 110         bool bNotifyAsynchronously = false);
 111
 112     virtual bool UpdateDescriptor (
 113         const SharedMasterPageDescriptor& rpDescriptor,
 114         bool bForcePageObject,
 115         bool bForcePreview,
 116         bool bSendEvents);
 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 (void);
 124
 125 private:
 126     Implementation (void);
 127     virtual ~Implementation (void);
 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     ::boost::scoped_ptr<MasterPageContainerQueue> mpRequestQueue;
 137     ::com::sun::star::uno::Reference<com::sun::star::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 arround 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> 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     ::boost::weak_ptr<sd::tools::TimerBasedTaskExecution> mpFillerTask;
 168
 169     Size maSmallPreviewSizePixel;
 170     Size maLargePreviewSizePixel;
 171     bool mbPageRatioKnown;
 172
 173     bool mbContainerCleaningPending;
 174
 175     typedef ::std::pair<MasterPageContainerChangeEvent::EventType,Token> EventData;
 176     DECL_LINK(AsynchronousNotifyCallback, EventData*);
 177     ::sd::DrawDocShell* LoadDocument (
 178         const String& sFileName,
 179         SfxObjectShellLock& rxDocumentShell);
 180
 181     Image GetPreviewSubstitution (sal_uInt16 nId, PreviewSize ePreviewSize);
 182
 183     void CleanContainer (void);
 184 };
 185
 186
 187
 188
 189 //===== MasterPageContainer ===================================================
 190
 191 ::boost::weak_ptr<MasterPageContainer::Implementation>
 192     MasterPageContainer::Implementation::mpInstance;
 193 static const MasterPageContainer::Token NIL_TOKEN (-1);
 194
 195
 196
 197
 198 ::boost::shared_ptr<MasterPageContainer::Implementation>
 199     MasterPageContainer::Implementation::Instance (void)
 200 {
 201     ::boost::shared_ptr<MasterPageContainer::Implementation> pInstance;
 202
 203     if (Implementation::mpInstance.expired())
 204     {
 205         ::osl::GetGlobalMutex aMutexFunctor;
 206         ::osl::MutexGuard aGuard (aMutexFunctor());
 207         if (Implementation::mpInstance.expired())
 208         {
 209             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 210             pInstance = ::boost::shared_ptr<MasterPageContainer::Implementation>(
 211                 new MasterPageContainer::Implementation(),
 212                 MasterPageContainer::Implementation::Deleter());
 213             SdGlobalResourceContainer::Instance().AddResource(pInstance);
 214             Implementation::mpInstance = pInstance;
 215         }
 216         else
 217             pInstance = ::boost::shared_ptr<MasterPageContainer::Implementation>(
 218                 Implementation::mpInstance);
 219     }
 220     else
 221     {
 222         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 223         pInstance = ::boost::shared_ptr<MasterPageContainer::Implementation>(
 224             Implementation::mpInstance);
 225     }
 226
 227     DBG_ASSERT (pInstance.get()!=NULL,
 228         "MasterPageContainer::Implementation::Instance(): instance is NULL");
 229     return pInstance;
 230 }
 231
 232
 233
 234
 235 MasterPageContainer::MasterPageContainer (void)
 236     : mpImpl(Implementation::Instance()),
 237       mePreviewSize(SMALL)
 238 {
 239     mpImpl->LateInit();
 240 }
 241
 242
 243
 244
 245 MasterPageContainer::~MasterPageContainer (void)
 246 {
 247 }
 248
 249
 250
 251
 252 void MasterPageContainer::AddChangeListener (const Link& rLink)
 253 {
 254     mpImpl->AddChangeListener(rLink);
 255 }
 256
 257
 258
 259
 260 void MasterPageContainer::RemoveChangeListener (const Link& rLink)
 261 {
 262     mpImpl->RemoveChangeListener(rLink);
 263 }
 264
 265
 266
 267
 268 void MasterPageContainer::SetPreviewSize (PreviewSize eSize)
 269 {
 270     mePreviewSize = eSize;
 271     mpImpl->FireContainerChange(
 272         MasterPageContainerChangeEvent::SIZE_CHANGED,
 273         NIL_TOKEN);
 274 }
 275
 276
 277
 278
 279 MasterPageContainer::PreviewSize MasterPageContainer::GetPreviewSize (void) const
 280 {
 281     return mePreviewSize;
 282 }
 283
 284
 285
 286
 287 Size MasterPageContainer::GetPreviewSizePixel (void) const
 288 {
 289     return mpImpl->GetPreviewSizePixel(mePreviewSize);
 290 }
 291
 292
 293
 294
 295 MasterPageContainer::Token MasterPageContainer::PutMasterPage (
 296     const SharedMasterPageDescriptor& rDescriptor)
 297 {
 298     return mpImpl->PutMasterPage(rDescriptor);
 299 }
 300
 301
 302
 303
 304 void MasterPageContainer::AcquireToken (Token aToken)
 305 {
 306     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 307     if (pDescriptor.get() != NULL)
 308     {
 309         ++pDescriptor->mnUseCount;
 310     }
 311 }
 312
 313
 314
 315
 316 void MasterPageContainer::ReleaseToken (Token aToken)
 317 {
 318     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 319     if (pDescriptor.get() != NULL)
 320     {
 321         OSL_ASSERT(pDescriptor->mnUseCount>0);
 322         --pDescriptor->mnUseCount;
 323         if (pDescriptor->mnUseCount <= 0)
 324         {
 325             switch (pDescriptor->meOrigin)
 326             {
 327                 case DEFAULT:
 328                 case TEMPLATE:
 329                 default:
 330                     break;
 331
 332                 case MASTERPAGE:
 333                     mpImpl->ReleaseDescriptor(aToken);
 334                     break;
 335             }
 336         }
 337     }
 338 }
 339
 340
 341
 342
 343 int MasterPageContainer::GetTokenCount (void) const
 344 {
 345     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 346
 347     return mpImpl->maContainer.size();
 348 }
 349
 350
 351
 352
 353 bool MasterPageContainer::HasToken (Token aToken) const
 354 {
 355     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 356
 357     return mpImpl->HasToken(aToken);
 358 }
 359
 360
 361
 362
 363 MasterPageContainer::Token MasterPageContainer::GetTokenForIndex (int nIndex)
 364 {
 365     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 366
 367     Token aResult (NIL_TOKEN);
 368     if (HasToken(nIndex))
 369         aResult = mpImpl->maContainer[nIndex]->maToken;
 370     return aResult;
 371 }
 372
 373
 374
 375
 376 MasterPageContainer::Token MasterPageContainer::GetTokenForURL (
 377     const String& sURL)
 378 {
 379     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 380
 381     Token aResult (NIL_TOKEN);
 382     if (sURL.Len() > 0)
 383     {
 384         MasterPageContainerType::iterator iEntry (
 385             ::std::find_if (
 386                 mpImpl->maContainer.begin(),
 387                 mpImpl->maContainer.end(),
 388                 MasterPageDescriptor::URLComparator(sURL)));
 389         if (iEntry != mpImpl->maContainer.end())
 390             aResult = (*iEntry)->maToken;
 391     }
 392     return aResult;
 393 }
 394
 395
 396
 397
 398 MasterPageContainer::Token MasterPageContainer::GetTokenForStyleName (const String& sStyleName)
 399 {
 400     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 401
 402     Token aResult (NIL_TOKEN);
 403     if (sStyleName.Len() > 0)
 404     {
 405         MasterPageContainerType::iterator iEntry (
 406             ::std::find_if (
 407                 mpImpl->maContainer.begin(),
 408                 mpImpl->maContainer.end(),
 409                 MasterPageDescriptor::StyleNameComparator(sStyleName)));
 410         if (iEntry != mpImpl->maContainer.end())
 411             aResult = (*iEntry)->maToken;
 412     }
 413     return aResult;
 414 }
 415
 416
 417
 418
 419 MasterPageContainer::Token MasterPageContainer::GetTokenForPageObject (
 420     const SdPage* pPage)
 421 {
 422     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 423
 424     Token aResult (NIL_TOKEN);
 425     if (pPage != NULL)
 426     {
 427         MasterPageContainerType::iterator iEntry (
 428             ::std::find_if (
 429                 mpImpl->maContainer.begin(),
 430                 mpImpl->maContainer.end(),
 431                 MasterPageDescriptor::PageObjectComparator(pPage)));
 432         if (iEntry != mpImpl->maContainer.end())
 433             aResult = (*iEntry)->maToken;
 434     }
 435     return aResult;
 436 }
 437
 438
 439
 440
 441 String MasterPageContainer::GetURLForToken (
 442     MasterPageContainer::Token aToken)
 443 {
 444     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 445
 446     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 447     if (pDescriptor.get() != NULL)
 448         return pDescriptor->msURL;
 449     else
 450         return String();
 451 }
 452
 453
 454
 455
 456 String MasterPageContainer::GetPageNameForToken (
 457     MasterPageContainer::Token aToken)
 458 {
 459     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 460
 461     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 462     if (pDescriptor.get() != NULL)
 463         return pDescriptor->msPageName;
 464     else
 465         return String();
 466 }
 467
 468
 469
 470
 471 String MasterPageContainer::GetStyleNameForToken (
 472     MasterPageContainer::Token aToken)
 473 {
 474     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 475
 476     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 477     if (pDescriptor.get() != NULL)
 478         return pDescriptor->msStyleName;
 479     else
 480         return String();
 481 }
 482
 483
 484
 485
 486 SdPage* MasterPageContainer::GetPageObjectForToken (
 487     MasterPageContainer::Token aToken,
 488     bool bLoad)
 489 {
 490     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 491
 492     SdPage* pPageObject = NULL;
 493     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 494     if (pDescriptor.get() != NULL)
 495     {
 496         pPageObject = pDescriptor->mpMasterPage;
 497         if (pPageObject == NULL)
 498         {
 499             // The page object is not (yet) present.  Call
 500             // UpdateDescriptor() to trigger the PageObjectProvider() to
 501             // provide it.
 502             if (bLoad)
 503                 mpImpl->GetModel();
 504             if (mpImpl->UpdateDescriptor(pDescriptor,bLoad,false, true))
 505                 pPageObject = pDescriptor->mpMasterPage;
 506         }
 507     }
 508     return pPageObject;
 509 }
 510
 511
 512
 513
 514 MasterPageContainer::Origin MasterPageContainer::GetOriginForToken (Token aToken)
 515 {
 516     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 517
 518     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 519     if (pDescriptor.get() != NULL)
 520         return pDescriptor->meOrigin;
 521     else
 522         return UNKNOWN;
 523 }
 524
 525
 526
 527
 528 sal_Int32 MasterPageContainer::GetTemplateIndexForToken (Token aToken)
 529 {
 530     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 531
 532     SharedMasterPageDescriptor pDescriptor = mpImpl->GetDescriptor(aToken);
 533     if (pDescriptor.get() != NULL)
 534         return pDescriptor->mnTemplateIndex;
 535     else
 536         return -1;
 537 }
 538
 539
 540
 541
 542 SharedMasterPageDescriptor MasterPageContainer::GetDescriptorForToken (
 543     MasterPageContainer::Token aToken)
 544 {
 545     const ::osl::MutexGuard aGuard (mpImpl->maMutex);
 546
 547     return mpImpl->GetDescriptor(aToken);
 548 }
 549
 550
 551
 552 void MasterPageContainer::InvalidatePreview (MasterPageContainer::Token aToken)
 553 {
 554     mpImpl->InvalidatePreview(aToken);
 555 }
 556
 557
 558
 559
 560 Image MasterPageContainer::GetPreviewForToken (MasterPageContainer::Token aToken)
 561 {
 562     return mpImpl->GetPreviewForToken(aToken,mePreviewSize);
 563 }
 564
 565
 566
 567
 568 MasterPageContainer::PreviewState MasterPageContainer::GetPreviewState (Token aToken)
 569 {
 570     return mpImpl->GetPreviewState(aToken);
 571 }
 572
 573
 574
 575
 576 bool MasterPageContainer::RequestPreview (Token aToken)
 577 {
 578     return mpImpl->RequestPreview(aToken);
 579 }
 580
 581
 582
 583
 584 //==== Implementation ================================================
 585
 586 MasterPageContainer::Implementation::Implementation (void)
 587     : maMutex(),
 588       maContainer(),
 589       meInitializationState(NOT_INITIALIZED),
 590       mpRequestQueue(NULL),
 591       mxModel(NULL),
 592       mpDocument(NULL),
 593       maPreviewRenderer(),
 594       mbFirstPageObjectSeen(false),
 595       maLargePreviewBeingCreated(),
 596       maSmallPreviewBeingCreated(),
 597       maLargePreviewNotAvailable(),
 598       maSmallPreviewNotAvailable(),
 599       maChangeListeners(),
 600       maSmallPreviewSizePixel(),
 601       maLargePreviewSizePixel(),
 602       mbPageRatioKnown(false),
 603       mbContainerCleaningPending(true)
 604
 605 {
 606     UpdatePreviewSizePixel();
 607 }
 608
 609
 610
 611
 612 MasterPageContainer::Implementation::~Implementation (void)
 613 {
 614     // When the initializer or filler tasks are still running then we have
 615     // to stop them now in order to prevent them from calling us back.
 616     tools::TimerBasedTaskExecution::ReleaseTask(mpFillerTask);
 617
 618     mpRequestQueue.reset();
 619
 620     uno::Reference<util::XCloseable> xCloseable (mxModel, uno::UNO_QUERY);
 621     if (xCloseable.is())
 622     {
 623         try
 624         {
 625             xCloseable->close(true);
 626         }
 627         catch (const ::com::sun::star::util::CloseVetoException&)
 628         {
 629         }
 630     }
 631     mxModel = NULL;
 632 }
 633
 634
 635
 636
 637 void MasterPageContainer::Implementation::LateInit (void)
 638 {
 639     const ::osl::MutexGuard aGuard (maMutex);
 640
 641     if (meInitializationState == NOT_INITIALIZED)
 642     {
 643         meInitializationState = INITIALIZING;
 644
 645         OSL_ASSERT(Instance().get()==this);
 646         mpRequestQueue.reset(MasterPageContainerQueue::Create(
 647             ::boost::shared_ptr<MasterPageContainerQueue::ContainerAdapter>(Instance())));
 648
 649         mpFillerTask = ::sd::tools::TimerBasedTaskExecution::Create(
 650             ::boost::shared_ptr<tools::AsynchronousTask>(new MasterPageContainerFiller(*this)),
 651             5,
 652             50);
 653
 654         meInitializationState = INITIALIZED;
 655     }
 656 }
 657
 658
 659
 660
 661 void MasterPageContainer::Implementation::AddChangeListener (const Link& rLink)
 662 {
 663     const ::osl::MutexGuard aGuard (maMutex);
 664
 665     ::std::vector<Link>::iterator iListener (
 666         ::std::find(maChangeListeners.begin(),maChangeListeners.end(),rLink));
 667     if (iListener == maChangeListeners.end())
 668         maChangeListeners.push_back(rLink);
 669
 670 }
 671
 672
 673
 674
 675 void MasterPageContainer::Implementation::RemoveChangeListener (const Link& rLink)
 676 {
 677     const ::osl::MutexGuard aGuard (maMutex);
 678
 679     ::std::vector<Link>::iterator iListener (
 680         ::std::find(maChangeListeners.begin(),maChangeListeners.end(),rLink));
 681     if (iListener != maChangeListeners.end())
 682         maChangeListeners.erase(iListener);
 683 }
 684
 685
 686
 687
 688 void MasterPageContainer::Implementation::UpdatePreviewSizePixel (void)
 689 {
 690     const ::osl::MutexGuard aGuard (maMutex);
 691
 692     // The default aspect ratio is 4:3
 693     int nWidth (4);
 694     int nHeight (3);
 695
 696     // Search for the first entry with an existing master page.
 697     MasterPageContainerType::const_iterator iDescriptor;
 698     MasterPageContainerType::const_iterator iContainerEnd(maContainer.end());
 699     for (iDescriptor=maContainer.begin(); iDescriptor!=iContainerEnd; ++iDescriptor)
 700         if (*iDescriptor!=NULL && (*iDescriptor)->mpMasterPage != NULL)
 701         {
 702             Size aPageSize ((*iDescriptor)->mpMasterPage->GetSize());
 703             OSL_ASSERT(aPageSize.Width() > 0 && aPageSize.Height() > 0);
 704             if (aPageSize.Width() > 0)
 705                 nWidth = aPageSize.Width();
 706             if (aPageSize.Height() > 0)
 707                 nHeight = aPageSize.Height();
 708             mbFirstPageObjectSeen = true;
 709             break;
 710         }
 711
 712     maSmallPreviewSizePixel.Width() = SMALL_PREVIEW_WIDTH;
 713     maLargePreviewSizePixel.Width() = LARGE_PREVIEW_WIDTH;
 714
 715     int nNewSmallHeight ((maSmallPreviewSizePixel.Width()-2) * nHeight / nWidth + 2);
 716     int nNewLargeHeight ((maLargePreviewSizePixel.Width()-2) * nHeight / nWidth + 2);
 717
 718     if (nNewSmallHeight!=maSmallPreviewSizePixel.Height()
 719         || nNewLargeHeight!=maLargePreviewSizePixel.Height())
 720     {
 721         maSmallPreviewSizePixel.Height() = nNewSmallHeight;
 722         maLargePreviewSizePixel.Height() = nNewLargeHeight;
 723         FireContainerChange(
 724             MasterPageContainerChangeEvent::SIZE_CHANGED,
 725             NIL_TOKEN);
 726     }
 727 }
 728
 729
 730
 731
 732 Size MasterPageContainer::Implementation::GetPreviewSizePixel (PreviewSize eSize) const
 733 {
 734     if (eSize == SMALL)
 735         return maSmallPreviewSizePixel;
 736     else
 737         return maLargePreviewSizePixel;
 738 }
 739
 740
 741
 742
 743 IMPL_LINK(MasterPageContainer::Implementation,AsynchronousNotifyCallback, EventData*, pData)
 744 {
 745     const ::osl::MutexGuard aGuard (maMutex);
 746
 747     if (pData != NULL)
 748     {
 749         FireContainerChange(pData->first, pData->second, false);
 750         delete pData;
 751     }
 752
 753     return 0;
 754 }
 755
 756
 757
 758
 759 MasterPageContainer::Token MasterPageContainer::Implementation::PutMasterPage (
 760     const SharedMasterPageDescriptor& rpDescriptor)
 761 {
 762     const ::osl::MutexGuard aGuard (maMutex);
 763
 764     Token aResult (NIL_TOKEN);
 765
 766     // Get page object and preview when that is inexpensive.
 767     UpdateDescriptor(rpDescriptor,false,false, false);
 768
 769     // Look up the new MasterPageDescriptor and either insert it or update
 770     // an already existing one.
 771     MasterPageContainerType::iterator aEntry (
 772         ::std::find_if (
 773             maContainer.begin(),
 774             maContainer.end(),
 775             MasterPageDescriptor::AllComparator(rpDescriptor)));
 776     if (aEntry == maContainer.end())
 777     {
 778         // Insert a new MasterPageDescriptor.
 779         bool bIgnore (rpDescriptor->mpPageObjectProvider.get()==NULL
 780             && rpDescriptor->msURL.isEmpty());
 781
 782         if ( ! bIgnore)
 783         {
 784             if (mbContainerCleaningPending)
 785                 CleanContainer();
 786
 787             aResult = maContainer.size();
 788             rpDescriptor->SetToken(aResult);
 789
 790             // Templates are precious, i.e. we lock them so that they will
 791             // not be destroyed when (temporarily) no one references them.
 792             // They will only be deleted when the container is destroyed.
 793             switch (rpDescriptor->meOrigin)
 794             {
 795                 case TEMPLATE:
 796                 case DEFAULT:
 797                     ++rpDescriptor->mnUseCount;
 798                     break;
 799
 800                 default:
 801                     break;
 802             }
 803
 804             maContainer.push_back(rpDescriptor);
 805             aEntry = maContainer.end()-1;
 806
 807             FireContainerChange(MasterPageContainerChangeEvent::CHILD_ADDED,aResult);
 808         }
 809     }
 810     else
 811     {
 812         // Update an existing MasterPageDescriptor.
 813         aResult = (*aEntry)->maToken;
 814         ::std::auto_ptr<std::vector<MasterPageContainerChangeEvent::EventType> > pEventTypes(
 815             (*aEntry)->Update(*rpDescriptor));
 816         if (pEventTypes.get()!=NULL && pEventTypes->size()>0)
 817         {
 818             // One or more aspects of the descriptor have changed.  Send
 819             // appropriate events to the listeners.
 820             UpdateDescriptor(*aEntry,false,false, true);
 821
 822             std::vector<MasterPageContainerChangeEvent::EventType>::const_iterator iEventType;
 823             for (iEventType=pEventTypes->begin(); iEventType!=pEventTypes->end(); ++iEventType)
 824             {
 825                 FireContainerChange(
 826                     *iEventType,
 827                     (*aEntry)->maToken,
 828                     false);
 829             }
 830         }
 831     }
 832
 833     return aResult;
 834 }
 835
 836
 837
 838
 839 bool MasterPageContainer::Implementation::HasToken (Token aToken) const
 840 {
 841     return aToken>=0
 842         && (unsigned)aToken<maContainer.size()
 843         && maContainer[aToken].get()!=NULL;
 844 }
 845
 846
 847
 848
 849 const SharedMasterPageDescriptor MasterPageContainer::Implementation::GetDescriptor (
 850     Token aToken) const
 851 {
 852     if (aToken>=0 && (unsigned)aToken<maContainer.size())
 853         return maContainer[aToken];
 854     else
 855         return SharedMasterPageDescriptor();
 856 }
 857
 858
 859
 860
 861 SharedMasterPageDescriptor MasterPageContainer::Implementation::GetDescriptor (Token aToken)
 862 {
 863     if (aToken>=0 && (unsigned)aToken<maContainer.size())
 864         return maContainer[aToken];
 865     else
 866         return SharedMasterPageDescriptor();
 867 }
 868
 869
 870
 871
 872 void MasterPageContainer::Implementation::InvalidatePreview (Token aToken)
 873 {
 874     const ::osl::MutexGuard aGuard (maMutex);
 875
 876     SharedMasterPageDescriptor pDescriptor (GetDescriptor(aToken));
 877     if (pDescriptor.get() != NULL)
 878     {
 879         pDescriptor->maSmallPreview = Image();
 880         pDescriptor->maLargePreview = Image();
 881         RequestPreview(aToken);
 882     }
 883 }
 884
 885
 886
 887
 888 Image MasterPageContainer::Implementation::GetPreviewForToken (
 889     MasterPageContainer::Token aToken,
 890     PreviewSize ePreviewSize)
 891 {
 892     const ::osl::MutexGuard aGuard (maMutex);
 893
 894     Image aPreview;
 895     PreviewState ePreviewState (GetPreviewState(aToken));
 896
 897     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 898
 899     // When the preview is missing but inexpensively creatable then do that
 900     // now.
 901     if (pDescriptor.get()!=NULL)
 902     {
 903         if (ePreviewState == PS_CREATABLE)
 904             if (UpdateDescriptor(pDescriptor, false,false, true))
 905                 if (pDescriptor->maLargePreview.GetSizePixel().Width() != 0)
 906                     ePreviewState = PS_AVAILABLE;
 907
 908         switch (ePreviewState)
 909         {
 910             case PS_AVAILABLE:
 911                 aPreview = pDescriptor->GetPreview(ePreviewSize);
 912                 break;
 913
 914             case PS_PREPARING:
 915                 aPreview = GetPreviewSubstitution(
 916                     STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION,
 917                     ePreviewSize);
 918                 break;
 919
 920             case PS_CREATABLE:
 921                 aPreview = GetPreviewSubstitution(
 922                     STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION,
 923                     ePreviewSize);
 924                 break;
 925
 926             case PS_NOT_AVAILABLE:
 927                 aPreview = GetPreviewSubstitution(
 928                     STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION,
 929                     ePreviewSize);
 930                 if (ePreviewSize == SMALL)
 931                     pDescriptor->maSmallPreview = aPreview;
 932                 else
 933                     pDescriptor->maLargePreview = aPreview;
 934                 break;
 935         }
 936     }
 937
 938     return aPreview;
 939 }
 940
 941
 942
 943
 944 MasterPageContainer::PreviewState MasterPageContainer::Implementation::GetPreviewState (
 945     Token aToken) const
 946 {
 947     const ::osl::MutexGuard aGuard (maMutex);
 948
 949     PreviewState eState (PS_NOT_AVAILABLE);
 950
 951     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 952     if (pDescriptor.get() != NULL)
 953     {
 954         if (pDescriptor->maLargePreview.GetSizePixel().Width() != 0)
 955             eState = PS_AVAILABLE;
 956         else if (pDescriptor->mpPreviewProvider.get() != NULL)
 957         {
 958             // The preview does not exist but can be created.  When that is
 959             // not expensive then do it at once.
 960             if (mpRequestQueue->HasRequest(aToken))
 961                 eState = PS_PREPARING;
 962             else
 963                 eState = PS_CREATABLE;
 964         }
 965         else
 966             eState = PS_NOT_AVAILABLE;
 967     }
 968
 969     return eState;
 970 }
 971
 972
 973
 974
 975 bool MasterPageContainer::Implementation::RequestPreview (Token aToken)
 976 {
 977     SharedMasterPageDescriptor pDescriptor = GetDescriptor(aToken);
 978     if (pDescriptor.get() != NULL)
 979         return mpRequestQueue->RequestPreview(pDescriptor);
 980     else
 981         return false;
 982 }
 983
 984
 985
 986
 987 Reference<frame::XModel> MasterPageContainer::Implementation::GetModel (void)
 988 {
 989     const ::osl::MutexGuard aGuard (maMutex);
 990
 991     if ( ! mxModel.is())
 992     {
 993         // Get the desktop a s service factory.
 994         uno::Reference<frame::XDesktop2> xDesktop  = frame::Desktop::create(
 995             ::comphelper::getProcessComponentContext() );
 996
 997         // Create a new model.
 998         OUString sModelServiceName ( "com.sun.star.presentation.PresentationDocument");
 999         mxModel = uno::Reference<frame::XModel>(
1000             ::comphelper::getProcessServiceFactory()->createInstance(
1001                 sModelServiceName),
1002             uno::UNO_QUERY);
1003
1004         // Initialize the model.
1005         uno::Reference<frame::XLoadable> xLoadable (mxModel,uno::UNO_QUERY);
1006         if (xLoadable.is())
1007             xLoadable->initNew();
1008
1009         // Use its tunnel to get a pointer to its core implementation.
1010         uno::Reference<lang::XUnoTunnel> xUnoTunnel (mxModel, uno::UNO_QUERY);
1011         if (xUnoTunnel.is())
1012         {
1013             mpDocument = reinterpret_cast<SdXImpressDocument*>(
1014                 xUnoTunnel->getSomething(
1015                     SdXImpressDocument::getUnoTunnelId()))->GetDoc();
1016         }
1017
1018         // Create a default page.
1019         uno::Reference<drawing::XDrawPagesSupplier> xSlideSupplier (mxModel, uno::UNO_QUERY);
1020         if (xSlideSupplier.is())
1021         {
1022             uno::Reference<drawing::XDrawPages> xSlides (
1023                 xSlideSupplier->getDrawPages(), uno::UNO_QUERY);
1024             if (xSlides.is())
1025             {
1026                 sal_Int32 nIndex (0);
1027                 uno::Reference<drawing::XDrawPage> xNewPage (xSlides->insertNewByIndex(nIndex));
1028                 uno::Reference<beans::XPropertySet> xProperties(xNewPage, uno::UNO_QUERY);
1029                 if (xProperties.is())
1030                     xProperties->setPropertyValue(
1031                         "Layout",
1032                         makeAny((sal_Int16)AUTOLAYOUT_TITLE));
1033             }
1034         }
1035     }
1036     return mxModel;
1037 }
1038
1039
1040
1041
1042 SdDrawDocument* MasterPageContainer::Implementation::GetDocument (void)
1043 {
1044     GetModel();
1045     return mpDocument;
1046 }
1047
1048
1049
1050
1051 Image MasterPageContainer::Implementation::GetPreviewSubstitution (
1052     sal_uInt16 nId,
1053     PreviewSize ePreviewSize)
1054 {
1055     const ::osl::MutexGuard aGuard (maMutex);
1056
1057     Image aPreview;
1058
1059     switch (nId)
1060     {
1061         case STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION:
1062         {
1063             Image& rPreview (ePreviewSize==SMALL
1064                 ? maSmallPreviewBeingCreated
1065                 : maLargePreviewBeingCreated);
1066             if (rPreview.GetSizePixel().Width() == 0)
1067             {
1068                 rPreview = maPreviewRenderer.RenderSubstitution(
1069                     ePreviewSize==SMALL ? maSmallPreviewSizePixel : maLargePreviewSizePixel,
1070                     SdResId(STR_TASKPANEL_PREPARING_PREVIEW_SUBSTITUTION));
1071             }
1072             aPreview = rPreview;
1073         }
1074         break;
1075
1076         case STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION:
1077         {
1078             Image& rPreview (ePreviewSize==SMALL
1079                 ? maSmallPreviewNotAvailable
1080                 : maLargePreviewNotAvailable);
1081             if (rPreview.GetSizePixel().Width() == 0)
1082             {
1083                 rPreview = maPreviewRenderer.RenderSubstitution(
1084                     ePreviewSize==SMALL ? maSmallPreviewSizePixel : maLargePreviewSizePixel,
1085                     SdResId(STR_TASKPANEL_NOT_AVAILABLE_SUBSTITUTION));
1086             }
1087             aPreview = rPreview;
1088         }
1089         break;
1090     }
1091
1092     return aPreview;
1093 }
1094
1095
1096
1097
1098 void MasterPageContainer::Implementation::CleanContainer (void)
1099 {
1100     // Remove the empty elements at the end of the container.  The empty
1101     // elements in the middle can not be removed because that would
1102     // invalidate the references still held by others.
1103     int nIndex (maContainer.size()-1);
1104     while (nIndex>=0 && maContainer[nIndex].get()==NULL)
1105         --nIndex;
1106     maContainer.resize(++nIndex);
1107 }
1108
1109
1110
1111
1112 void MasterPageContainer::Implementation::FireContainerChange (
1113     MasterPageContainerChangeEvent::EventType eType,
1114     Token aToken,
1115     bool bNotifyAsynchronously)
1116 {
1117     if (bNotifyAsynchronously)
1118     {
1119         Application::PostUserEvent(
1120             LINK(this,Implementation,AsynchronousNotifyCallback),
1121             new EventData(eType,aToken));
1122     }
1123     else
1124     {
1125         ::std::vector<Link> aCopy(maChangeListeners.begin(),maChangeListeners.end());
1126         ::std::vector<Link>::iterator iListener;
1127         MasterPageContainerChangeEvent aEvent;
1128         aEvent.meEventType = eType;
1129         aEvent.maChildToken = aToken;
1130         for (iListener=aCopy.begin(); iListener!=aCopy.end(); ++iListener)
1131             iListener->Call(&aEvent);
1132     }
1133 }
1134
1135
1136
1137
1138 bool MasterPageContainer::Implementation::UpdateDescriptor (
1139     const SharedMasterPageDescriptor& rpDescriptor,
1140     bool bForcePageObject,
1141     bool bForcePreview,
1142     bool bSendEvents)
1143 {
1144     const ::osl::MutexGuard aGuard (maMutex);
1145
1146     // We have to create the page object when the preview provider needs it
1147     // and the caller needs the preview.
1148     bForcePageObject |= (bForcePreview
1149         && rpDescriptor->mpPreviewProvider->NeedsPageObject()
1150         && rpDescriptor->mpMasterPage==NULL);
1151
1152     // Define a cost threshold so that an update or page object or preview
1153     // that is at least this cost are made at once. Updates with higher cost
1154     // are scheduled for later.
1155     sal_Int32 nCostThreshold (mpRequestQueue->IsEmpty() ? 5 : 0);
1156
1157     // Update the page object (which may be used for the preview update).
1158     if (bForcePageObject)
1159         GetDocument();
1160     int nPageObjectModified (rpDescriptor->UpdatePageObject(
1161         (bForcePageObject ? -1 : nCostThreshold),
1162         mpDocument));
1163     if (nPageObjectModified == 1 && bSendEvents)
1164         FireContainerChange(
1165             MasterPageContainerChangeEvent::DATA_CHANGED,
1166             rpDescriptor->maToken);
1167     if (nPageObjectModified == -1 && bSendEvents)
1168         FireContainerChange(
1169             MasterPageContainerChangeEvent::CHILD_REMOVED,
1170             rpDescriptor->maToken);
1171     if (nPageObjectModified && ! mbFirstPageObjectSeen)
1172         UpdatePreviewSizePixel();
1173
1174     // Update the preview.
1175     bool bPreviewModified (rpDescriptor->UpdatePreview(
1176         (bForcePreview ? -1 : nCostThreshold),
1177         maSmallPreviewSizePixel,
1178         maLargePreviewSizePixel,
1179         maPreviewRenderer));
1180
1181     if (bPreviewModified && bSendEvents)
1182         FireContainerChange(
1183             MasterPageContainerChangeEvent::PREVIEW_CHANGED,
1184             rpDescriptor->maToken);
1185
1186     return nPageObjectModified || bPreviewModified;
1187 }
1188
1189
1190
1191
1192 void MasterPageContainer::Implementation::ReleaseDescriptor (Token aToken)
1193 {
1194     if (aToken>=0 && (unsigned)aToken<maContainer.size())
1195     {
1196         maContainer[aToken].reset();
1197         mbContainerCleaningPending = true;
1198     }
1199 }
1200
1201
1202
1203
1204 void MasterPageContainer::Implementation::FillingDone (void)
1205 {
1206     mpRequestQueue->ProcessAllRequests();
1207 }
1208
1209
1210
1211 } } } // end of namespace ::sd::toolpanel::controls
1212
1213 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */