sd/source/ui/slidesorter/model/SlideSorterModel.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SlideSorterModel.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sd.hxx"
  32
  33 #include "model/SlideSorterModel.hxx"
  34
  35 #include "SlideSorter.hxx"
  36 #include "model/SlsPageDescriptor.hxx"
  37 #include "model/SlsPageEnumerationProvider.hxx"
  38 #include "controller/SlideSorterController.hxx"
  39 #include "controller/SlsPageObjectFactory.hxx"
  40 #include "controller/SlsProperties.hxx"
  41 #include "controller/SlsPageSelector.hxx"
  42 #include "controller/SlsCurrentSlideManager.hxx"
  43 #include "view/SlideSorterView.hxx"
  44 #include "taskpane/SlideSorterCacheDisplay.hxx"
  45 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  46 #include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
  47 #include <com/sun/star/beans/XPropertySet.hpp>
  48 #include <com/sun/star/beans/UnknownPropertyException.hpp>
  49
  50 #include "ViewShellBase.hxx"
  51 #include "DrawViewShell.hxx"
  52 #include "drawdoc.hxx"
  53 #include "sdpage.hxx"
  54 #include "FrameView.hxx"
  55
  56 using namespace ::com::sun::star;
  57 using namespace ::com::sun::star::uno;
  58
  59 namespace sd { namespace slidesorter { namespace model {
  60
  61 namespace {
  62     class CompareToXDrawPage
  63     {
  64     public:
  65         CompareToXDrawPage (const Reference<drawing::XDrawPage>& rxSlide) : mxSlide(rxSlide) {}
  66         bool operator() (const SharedPageDescriptor& rpDescriptor)
  67         { return rpDescriptor.get()!=NULL && rpDescriptor->GetXDrawPage()==mxSlide; }
  68     private:
  69         Reference<drawing::XDrawPage> mxSlide;
  70     };
  71 }
  72
  73
  74
  75
  76 SlideSorterModel::SlideSorterModel (SlideSorter& rSlideSorter)
  77     : maMutex(),
  78       mrSlideSorter(rSlideSorter),
  79       mxSlides(),
  80       mePageKind(PK_STANDARD),
  81       meEditMode(EM_PAGE),
  82       maPageDescriptors(0),
  83       mpPageObjectFactory(NULL)
  84 {
  85 }
  86
  87
  88
  89
  90 SlideSorterModel::~SlideSorterModel (void)
  91 {
  92     ClearDescriptorList ();
  93 }
  94
  95
  96
  97
  98 SdDrawDocument* SlideSorterModel::GetDocument (void)
  99 {
 100     if (mrSlideSorter.GetViewShellBase() != NULL)
 101         return mrSlideSorter.GetViewShellBase()->GetDocument();
 102     else
 103          return NULL;
 104 }
 105
 106
 107
 108
 109 bool SlideSorterModel::SetEditMode (EditMode eEditMode)
 110 {
 111     bool bEditModeChanged = false;
 112     if (meEditMode != eEditMode)
 113     {
 114         meEditMode = eEditMode;
 115         UpdatePageList();
 116         ClearDescriptorList();
 117         bEditModeChanged = true;
 118     }
 119     return bEditModeChanged;
 120 }
 121
 122
 123
 124
 125 bool SlideSorterModel::SetEditModeFromController (void)
 126 {
 127     bool bIsMasterPageMode = false;
 128     // Get the edit mode from the controller.
 129     try
 130     {
 131         Reference<beans::XPropertySet> xSet (mrSlideSorter.GetXController(), UNO_QUERY_THROW);
 132         Any aValue (xSet->getPropertyValue(
 133             ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IsMasterPageMode"))));
 134         aValue >>= bIsMasterPageMode;
 135     }
 136     catch (RuntimeException&)
 137     {
 138         // When the property is not supported then the master
 139         // page mode is not supported, too.
 140         bIsMasterPageMode = false;
 141     }
 142
 143     return SetEditMode(bIsMasterPageMode ? EM_MASTERPAGE : EM_PAGE);
 144 }
 145
 146
 147
 148
 149 EditMode SlideSorterModel::GetEditMode (void) const
 150 {
 151     return meEditMode;
 152 }
 153
 154
 155
 156
 157 PageKind SlideSorterModel::GetPageType (void) const
 158 {
 159     return mePageKind;
 160 }
 161
 162
 163
 164
 165 sal_Int32 SlideSorterModel::GetPageCount (void) const
 166 {
 167     return maPageDescriptors.size();
 168 }
 169
 170
 171
 172
 173 SharedPageDescriptor SlideSorterModel::GetPageDescriptor (
 174     const sal_Int32 nPageIndex,
 175     const bool bCreate) const
 176 {
 177     ::osl::MutexGuard aGuard (maMutex);
 178
 179     SharedPageDescriptor pDescriptor;
 180
 181     if (nPageIndex>=0 && nPageIndex<GetPageCount())
 182     {
 183         pDescriptor = maPageDescriptors[nPageIndex];
 184         if (pDescriptor == NULL && bCreate && mxSlides.is())
 185         {
 186             SdDrawDocument* pModel = const_cast<SlideSorterModel*>(this)->GetDocument();
 187             SdPage* pPage = NULL;
 188             if (pModel != NULL)
 189             {
 190                 if (meEditMode == EM_PAGE)
 191                     pPage = pModel->GetSdPage ((USHORT)nPageIndex, mePageKind);
 192                 else
 193                     pPage = pModel->GetMasterSdPage ((USHORT)nPageIndex, mePageKind);
 194             }
 195             pDescriptor.reset(new PageDescriptor (
 196                 Reference<drawing::XDrawPage>(mxSlides->getByIndex(nPageIndex),UNO_QUERY),
 197                 pPage,
 198                 nPageIndex,
 199                 GetPageObjectFactory()));
 200             maPageDescriptors[nPageIndex] = pDescriptor;
 201         }
 202     }
 203
 204     return pDescriptor;
 205 }
 206
 207
 208
 209
 210 sal_Int32 SlideSorterModel::GetIndex (const Reference<drawing::XDrawPage>& rxSlide) const
 211 {
 212     ::osl::MutexGuard aGuard (maMutex);
 213
 214     // First try to guess the right index.
 215     Reference<beans::XPropertySet> xSet (rxSlide, UNO_QUERY);
 216     if (xSet.is())
 217     {
 218         try
 219         {
 220             const Any aNumber (xSet->getPropertyValue(::rtl::OUString::createFromAscii("Number")));
 221             sal_Int16 nNumber (-1);
 222             aNumber >>= nNumber;
 223             nNumber -= 1;
 224             SharedPageDescriptor pDescriptor (GetPageDescriptor(nNumber, false));
 225             if (pDescriptor.get() != NULL
 226                 && pDescriptor->GetXDrawPage() == rxSlide)
 227             {
 228                 return nNumber;
 229             }
 230         }
 231         catch (beans::UnknownPropertyException&)
 232         {
 233             OSL_ASSERT(false);
 234         }
 235         catch (lang::DisposedException&)
 236         {
 237             OSL_ASSERT(false);
 238         }
 239     }
 240
 241     // Guess was wrong, iterate over all slides and search for the right
 242     // one.
 243     const sal_Int32 nCount (maPageDescriptors.size());
 244     for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
 245     {
 246         SharedPageDescriptor pDescriptor (maPageDescriptors[nIndex]);
 247
 248         // Make sure that the descriptor exists.  Without it the given slide
 249         // can not be found.
 250         if (pDescriptor.get() == NULL)
 251         {
 252             // Call GetPageDescriptor() to create the missing descriptor.
 253             pDescriptor = GetPageDescriptor(nIndex,true);
 254         }
 255
 256         if (pDescriptor->GetXDrawPage() == rxSlide)
 257             return nIndex;
 258     }
 259
 260     return  -1;
 261 }
 262
 263
 264
 265
 266 /** For now this method uses a trivial algorithm: throw away all descriptors
 267     and create them anew (on demand).  The main problem that we are facing
 268     when designing a better algorithm is that we can not compare pointers to
 269     pages stored in the PageDescriptor objects and those obtained from the
 270     document: pages may have been deleted and others may have been created
 271     at the exact same memory locations.
 272 */
 273 void SlideSorterModel::Resync (void)
 274 {
 275     ::osl::MutexGuard aGuard (maMutex);
 276     ClearDescriptorList ();
 277     AdaptSize();
 278 }
 279
 280
 281
 282
 283 void SlideSorterModel::ClearDescriptorList (void)
 284 {
 285     ::osl::MutexGuard aGuard (maMutex);
 286
 287     // Clear the cache of page descriptors.
 288     DescriptorContainer::iterator I;
 289     for (I=maPageDescriptors.begin(); I!=maPageDescriptors.end(); I++)
 290     {
 291         if (I->get() != NULL)
 292         {
 293             if ( ! I->unique())
 294             {
 295                 OSL_TRACE("SlideSorterModel::ClearDescriptorList: trying to delete page descriptor  that is still used with count %d", I->use_count());
 296                 // No assertion here because that can hang the office when
 297                 // opening a dialog from here.
 298             }
 299             I->reset();
 300         }
 301     }
 302 }
 303
 304
 305
 306
 307 void SlideSorterModel::SynchronizeDocumentSelection (void)
 308 {
 309     ::osl::MutexGuard aGuard (maMutex);
 310
 311     PageEnumeration aAllPages (PageEnumerationProvider::CreateAllPagesEnumeration(*this));
 312     while (aAllPages.HasMoreElements())
 313     {
 314         SharedPageDescriptor pDescriptor (aAllPages.GetNextElement());
 315         pDescriptor->GetPage()->SetSelected (pDescriptor->IsSelected());
 316     }
 317 }
 318
 319
 320
 321
 322 void SlideSorterModel::SynchronizeModelSelection (void)
 323 {
 324     ::osl::MutexGuard aGuard (maMutex);
 325
 326     PageEnumeration aAllPages (PageEnumerationProvider::CreateAllPagesEnumeration(*this));
 327     while (aAllPages.HasMoreElements())
 328     {
 329         SharedPageDescriptor pDescriptor (aAllPages.GetNextElement());
 330         if (pDescriptor->GetPage()->IsSelected())
 331             pDescriptor->Select ();
 332         else
 333             pDescriptor->Deselect ();
 334     }
 335 }
 336
 337
 338
 339
 340 void SlideSorterModel::SetPageObjectFactory(
 341     ::std::auto_ptr<controller::PageObjectFactory> pPageObjectFactory)
 342 {
 343     ::osl::MutexGuard aGuard (maMutex);
 344
 345     mpPageObjectFactory = pPageObjectFactory;
 346     // When a NULL pointer was given then create a default factory.
 347     const controller::PageObjectFactory& rFactory (GetPageObjectFactory());
 348     PageEnumeration aAllPages (PageEnumerationProvider::CreateAllPagesEnumeration(*this));
 349     while (aAllPages.HasMoreElements())
 350     {
 351         SharedPageDescriptor pDescriptor (aAllPages.GetNextElement());
 352         pDescriptor->SetPageObjectFactory(rFactory);
 353     }
 354 }
 355
 356
 357
 358
 359 const controller::PageObjectFactory&
 360     SlideSorterModel::GetPageObjectFactory (void) const
 361 {
 362     ::osl::MutexGuard aGuard (maMutex);
 363
 364     if (mpPageObjectFactory.get() == NULL)
 365     {
 366         // We have to create a new factory.  The pointer is mutable so we
 367         // are alowed to do so.
 368         mpPageObjectFactory = ::std::auto_ptr<controller::PageObjectFactory> (
 369             new controller::PageObjectFactory(
 370                 mrSlideSorter.GetView().GetPreviewCache(),
 371                 mrSlideSorter.GetController().GetProperties()));
 372     }
 373     return *mpPageObjectFactory.get();
 374 }
 375
 376
 377
 378
 379 ::osl::Mutex& SlideSorterModel::GetMutex (void)
 380 {
 381     return maMutex;
 382 }
 383
 384
 385
 386
 387 void SlideSorterModel::SetDocumentSlides (
 388     const Reference<container::XIndexAccess>& rxSlides)
 389 {
 390     ::osl::MutexGuard aGuard (maMutex);
 391
 392     // Reset the current page so to cause everbody to release references to it.
 393     mrSlideSorter.GetController().GetCurrentSlideManager()->CurrentSlideHasChanged(-1);
 394
 395     mxSlides = rxSlides;
 396     Resync();
 397
 398     ViewShell* pViewShell = mrSlideSorter.GetViewShell();
 399     if (pViewShell != NULL)
 400     {
 401         SdPage* pPage = pViewShell->getCurrentPage();
 402         if (pPage != NULL)
 403             mrSlideSorter.GetController().GetCurrentSlideManager()->CurrentSlideHasChanged(
 404                 GetIndex(Reference<drawing::XDrawPage>(pPage->getUnoPage(), UNO_QUERY)));
 405         else
 406         {
 407             // No current page.  This can only be when the slide sorter is
 408             // the main view shell.  Get current slide form frame view.
 409             const FrameView* pFrameView = pViewShell->GetFrameView();
 410             if (pFrameView != NULL)
 411                 mrSlideSorter.GetController().GetCurrentSlideManager()->CurrentSlideHasChanged(
 412                     pFrameView->GetSelectedPage());
 413             else
 414             {
 415                 // No frame view.  As a last resort use the first slide as
 416                 // current slide.
 417                 mrSlideSorter.GetController().GetCurrentSlideManager()->CurrentSlideHasChanged(0);
 418             }
 419         }
 420     }
 421 }
 422
 423
 424
 425
 426 Reference<container::XIndexAccess> SlideSorterModel::GetDocumentSlides (void) const
 427 {
 428     ::osl::MutexGuard aGuard (maMutex);
 429     return mxSlides;
 430 }
 431
 432
 433
 434
 435 void SlideSorterModel::UpdatePageList (void)
 436 {
 437     ::osl::MutexGuard aGuard (maMutex);
 438
 439     Reference<container::XIndexAccess> xPages;
 440
 441     // Get the list of pages according to the edit mode.
 442     Reference<frame::XController> xController (mrSlideSorter.GetXController());
 443     if (xController.is())
 444     {
 445         switch (meEditMode)
 446         {
 447             case EM_MASTERPAGE:
 448             {
 449                 Reference<drawing::XMasterPagesSupplier> xSupplier (
 450                     xController->getModel(), UNO_QUERY);
 451                 if (xSupplier.is())
 452                 {
 453                     xPages = Reference<container::XIndexAccess>(
 454                         xSupplier->getMasterPages(), UNO_QUERY);
 455                 }
 456             }
 457             break;
 458
 459             case EM_PAGE:
 460             {
 461                 Reference<drawing::XDrawPagesSupplier> xSupplier (
 462                     xController->getModel(), UNO_QUERY);
 463                 if (xSupplier.is())
 464                 {
 465                     xPages = Reference<container::XIndexAccess>(
 466                         xSupplier->getDrawPages(), UNO_QUERY);
 467                 }
 468             }
 469             break;
 470
 471             default:
 472                 // We should never get here.
 473                 OSL_ASSERT(false);
 474                 break;
 475         }
 476     }
 477
 478     mrSlideSorter.GetController().SetDocumentSlides(xPages);
 479 }
 480
 481
 482
 483
 484 void SlideSorterModel::AdaptSize (void)
 485 {
 486     if (mxSlides.is())
 487         maPageDescriptors.resize(mxSlides->getCount());
 488     else
 489         maPageDescriptors.resize(0);
 490 }
 491
 492 } } } // end of namespace ::sd::slidesorter::model