sd/source/ui/toolpanel/controls/MasterPagesSelector.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: MasterPagesSelector.cxx,v $
  10  * $Revision: 1.22 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "MasterPagesSelector.hxx"
  35
  36 #include "MasterPageContainer.hxx"
  37 #include "DocumentHelper.hxx"
  38 #include "pres.hxx"
  39 #include "drawdoc.hxx"
  40 #include "DrawDocShell.hxx"
  41 #include "sdpage.hxx"
  42 #include "glob.hxx"
  43 #include "glob.hrc"
  44 #include "app.hrc"
  45 #include "res_bmp.hrc"
  46 #include "strings.hrc"
  47 #include "showview.hxx"
  48 #include "DrawViewShell.hxx"
  49 #include "DrawController.hxx"
  50 #include "SlideSorterViewShell.hxx"
  51 #include "PreviewValueSet.hxx"
  52 #include "ViewShellBase.hxx"
  53 #include "../TaskPaneShellManager.hxx"
  54 #include "taskpane/TitledControl.hxx"
  55 #include "taskpane/ControlContainer.hxx"
  56 #include "controller/SlideSorterController.hxx"
  57 #include "controller/SlsPageSelector.hxx"
  58 #include <sfx2/objface.hxx>
  59 #include "sdresid.hxx"
  60 #include "TemplateScanner.hxx"
  61 #ifndef _SD_DRAWVIEW_HXX
  62 #include "drawview.hxx"
  63 #endif
  64 #include <vcl/image.hxx>
  65 #include <svtools/languageoptions.hxx>
  66 #include <sfx2/app.hxx>
  67 #include <sfx2/dispatch.hxx>
  68 #include <sfx2/mnumgr.hxx>
  69 #include <svtools/itemset.hxx>
  70 #include <svtools/eitem.hxx>
  71 #include <svx/dlgutil.hxx>
  72 #include <svx/svdpagv.hxx>
  73 #include <svx/svxids.hrc>
  74 #include "FrameView.hxx"
  75 #include "sdpage.hxx"
  76 #include "stlpool.hxx"
  77 #include "unmovss.hxx"
  78 #include <sfx2/request.hxx>
  79 #include <svtools/itempool.hxx>
  80
  81 using namespace ::sd::toolpanel::controls;
  82 #define MasterPagesSelector
  83 #include "sdslots.hxx"
  84
  85 using namespace ::com::sun::star::text;
  86
  87
  88
  89 namespace sd { namespace toolpanel { namespace controls {
  90
  91
  92 SFX_IMPL_INTERFACE(MasterPagesSelector, SfxShell,
  93     SdResId(STR_MASTERPAGESSELECTOR))
  94 {
  95     SFX_POPUPMENU_REGISTRATION( SdResId(RID_TASKPANE_MASTERPAGESSELECTOR_POPUP) );
  96 }
  97
  98 TYPEINIT1(MasterPagesSelector, SfxShell);
  99
 100
 101
 102 MasterPagesSelector::MasterPagesSelector (
 103     TreeNode* pParent,
 104     SdDrawDocument& rDocument,
 105     ViewShellBase& rBase,
 106     const ::boost::shared_ptr<MasterPageContainer>& rpContainer)
 107     : TreeNode (pParent),
 108       SfxShell(),
 109       maMutex(),
 110       mpContainer(rpContainer),
 111       mrDocument(rDocument),
 112       mpPageSet (new PreviewValueSet(pParent)),
 113       mrBase(rBase),
 114       mnDefaultClickAction(SID_TP_APPLY_TO_ALL_SLIDES),
 115       maPreviewUpdateQueue(),
 116       maCurrentItemList(),
 117       maTokenToValueSetIndex(),
 118       maLockedMasterPages()
 119 {
 120     SetPool (&rDocument.GetPool());
 121
 122     mpPageSet->SetSelectHdl (
 123         LINK(this, MasterPagesSelector, ClickHandler));
 124     mpPageSet->SetRightMouseClickHandler (
 125         LINK(this, MasterPagesSelector, RightClickHandler));
 126     mpPageSet->SetContextMenuCallback (
 127         LINK(this, MasterPagesSelector, ContextMenuCallback));
 128     mpPageSet->SetStyle(mpPageSet->GetStyle() | WB_NO_DIRECTSELECT);
 129     mpPageSet->SetPreviewSize(mpContainer->GetPreviewSizePixel());
 130     mpPageSet->Show();
 131
 132     Link aChangeListener (LINK(this,MasterPagesSelector,ContainerChangeListener));
 133     mpContainer->AddChangeListener(aChangeListener);
 134 }
 135
 136
 137
 138
 139 MasterPagesSelector::~MasterPagesSelector (void)
 140 {
 141     Clear();
 142     mpPageSet.reset();
 143     UpdateLocks(ItemList());
 144
 145     if (GetShellManager() != NULL)
 146         GetShellManager()->RemoveSubShell (this);
 147
 148     Link aChangeListener (LINK(this,MasterPagesSelector,ContainerChangeListener));
 149     mpContainer->RemoveChangeListener(aChangeListener);
 150 }
 151
 152
 153
 154
 155 void MasterPagesSelector::LateInit (void)
 156 {
 157 }
 158
 159
 160
 161
 162 sal_Int32 MasterPagesSelector::GetPreferredWidth (sal_Int32 nHeight)
 163 {
 164     const ::osl::MutexGuard aGuard (maMutex);
 165
 166     return mpPageSet->GetPreferredWidth (nHeight);
 167 }
 168
 169
 170
 171
 172 sal_Int32 MasterPagesSelector::GetPreferredHeight (sal_Int32 nWidth)
 173 {
 174     const ::osl::MutexGuard aGuard (maMutex);
 175
 176     return mpPageSet->GetPreferredHeight (nWidth);
 177 }
 178
 179
 180
 181
 182 Size MasterPagesSelector::GetPreferredSize (void)
 183 {
 184     int nPreferredWidth = GetPreferredWidth(
 185         mpPageSet->GetOutputSizePixel().Height());
 186     int nPreferredHeight = GetPreferredHeight(nPreferredWidth);
 187     return Size (nPreferredWidth, nPreferredHeight);
 188
 189 }
 190
 191
 192
 193
 194 void MasterPagesSelector::UpdateLocks (const ItemList& rItemList)
 195 {
 196     ItemList aNewLockList;
 197
 198     // In here we first lock the master pages in the given list and then
 199     // release the locks acquired in a previous call to this method.  When
 200     // this were done the other way round the lock count of some master
 201     // pages might drop temporarily to 0 and would lead to unnecessary
 202     // deletion and re-creation of MasterPageDescriptor objects.
 203
 204     // Lock the master pages in the given list.
 205     ItemList::const_iterator iItem;
 206     for (iItem=rItemList.begin(); iItem!=rItemList.end(); ++iItem)
 207     {
 208         mpContainer->AcquireToken(*iItem);
 209         aNewLockList.push_back(*iItem);
 210     }
 211
 212     // Release the previously locked master pages.
 213     ItemList::const_iterator iPage;
 214     ItemList::const_iterator iEnd (maLockedMasterPages.end());
 215     for (iPage=maLockedMasterPages.begin(); iPage!=iEnd; ++iPage)
 216         mpContainer->ReleaseToken(*iPage);
 217
 218     maLockedMasterPages.swap(aNewLockList);
 219 }
 220
 221
 222
 223
 224 void MasterPagesSelector::Fill (void)
 225 {
 226     ::std::auto_ptr<ItemList> pItemList (new ItemList());
 227
 228     Fill(*pItemList);
 229
 230     UpdateLocks(*pItemList);
 231     UpdateItemList(pItemList);
 232 }
 233
 234
 235
 236
 237 ResId MasterPagesSelector::GetContextMenuResId (void) const
 238 {
 239     return SdResId(RID_TASKPANE_MASTERPAGESSELECTOR_POPUP);
 240 }
 241
 242
 243
 244
 245 IMPL_LINK(MasterPagesSelector, ClickHandler, PreviewValueSet*, EMPTYARG)
 246 {
 247     // We use the framework to assign the clicked-on master page because we
 248     // so use the same mechanism as the context menu does (where we do not
 249     // have the option to call the assignment method directly.)
 250     if (GetShellManager() != NULL)
 251         GetShellManager()->MoveToTop (this);
 252
 253     SfxViewFrame* pViewFrame = mrBase.GetViewFrame();
 254     if (pViewFrame != NULL)
 255     {
 256         SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher();
 257         if (pDispatcher != NULL)
 258             pDispatcher->Execute(mnDefaultClickAction);
 259     }
 260
 261     return 0;
 262 }
 263
 264
 265
 266
 267 IMPL_LINK(MasterPagesSelector, RightClickHandler, MouseEvent*, pEvent)
 268 {
 269     // Here we only prepare the display of the context menu: the item under
 270     // the mouse is selected.  The actual display of the context menu is
 271     // done in ContextMenuCallback which is called indirectly through
 272     // PreviewValueSet::Command().
 273     mpPageSet->GrabFocus ();
 274     mpPageSet->ReleaseMouse();
 275     if (GetDispatcher() != NULL &&  pEvent != NULL)
 276     {
 277         USHORT nIndex = mpPageSet->GetItemId (pEvent->GetPosPixel());
 278         if (nIndex > 0)
 279             mpPageSet->SelectItem (nIndex);
 280     }
 281     return 0;
 282 }
 283
 284
 285
 286
 287 IMPL_LINK(MasterPagesSelector, ContextMenuCallback, CommandEvent*, pEvent)
 288 {
 289     // Use the currently selected item and show the popup menu in its
 290     // center.
 291     if (GetShellManager() != NULL)
 292         GetShellManager()->MoveToTop (this);
 293     const USHORT nIndex = mpPageSet->GetSelectItemId();
 294     if (nIndex > 0 && pEvent!=NULL)
 295     {
 296         // The position of the upper left corner of the context menu is
 297         // taken either from the mouse position (when the command was sent
 298         // as reaction to a right click) or in the center of the selected
 299         // item (when the command was sent as reaction to Shift+F10.)
 300         Point aPosition (pEvent->GetMousePosPixel());
 301         if ( ! pEvent->IsMouseEvent())
 302         {
 303             Rectangle aBBox (mpPageSet->GetItemRect(nIndex));
 304             aPosition = aBBox.Center();
 305         }
 306
 307         const ResId aPopupResId (GetContextMenuResId());
 308         mrBase.GetViewFrame()->GetDispatcher()->ExecutePopup(
 309             aPopupResId,
 310             mpPageSet.get(),
 311             &aPosition);
 312     }
 313
 314     return 0;
 315 }
 316
 317
 318
 319
 320 IMPL_LINK(MasterPagesSelector, ContainerChangeListener, MasterPageContainerChangeEvent*, pEvent)
 321 {
 322     if (pEvent)
 323         NotifyContainerChangeEvent(*pEvent);
 324     return 0;
 325 }
 326
 327
 328
 329
 330 SdPage* MasterPagesSelector::GetSelectedMasterPage (void)
 331 {
 332     const ::osl::MutexGuard aGuard (maMutex);
 333
 334     SdPage* pMasterPage = NULL;
 335     USHORT nIndex = mpPageSet->GetSelectItemId();
 336     UserData* pData = GetUserData(nIndex);
 337     if (pData != NULL)
 338     {
 339         pMasterPage = mpContainer->GetPageObjectForToken(pData->second);
 340     }
 341     return pMasterPage;
 342 }
 343
 344
 345
 346
 347 /** Assemble a list of all slides of the document and pass it to
 348     AssignMasterPageToPageList().
 349 */
 350 void MasterPagesSelector::AssignMasterPageToAllSlides (SdPage* pMasterPage)
 351 {
 352     do
 353     {
 354         if (pMasterPage == NULL)
 355             break;
 356
 357         USHORT nPageCount = mrDocument.GetSdPageCount(PK_STANDARD);
 358         if (nPageCount == 0)
 359             break;
 360
 361         // Get a list of all pages.  As a little optimization we only
 362         // include pages that do not already have the given master page
 363         // assigned.
 364         String sFullLayoutName (pMasterPage->GetLayoutName());
 365         ::sd::slidesorter::SharedPageSelection pPageList (
 366             new ::sd::slidesorter::SlideSorterViewShell::PageSelection());
 367         for (USHORT nPageIndex=0; nPageIndex<nPageCount; nPageIndex++)
 368         {
 369             SdPage* pPage = mrDocument.GetSdPage (nPageIndex, PK_STANDARD);
 370             if (pPage != NULL
 371                 && pPage->GetLayoutName().CompareTo(sFullLayoutName)!=0)
 372             {
 373                 pPageList->push_back (pPage);
 374             }
 375         }
 376
 377         AssignMasterPageToPageList(pMasterPage, pPageList);
 378     }
 379     while (false);
 380 }
 381
 382
 383
 384
 385 /** Assemble a list of the currently selected slides (selected in a visible
 386     slide sorter) and pass it to AssignMasterPageToPageList().
 387 */
 388 void MasterPagesSelector::AssignMasterPageToSelectedSlides (
 389     SdPage* pMasterPage)
 390 {
 391     do
 392     {
 393         using namespace ::std;
 394         using namespace ::sd::slidesorter;
 395         using namespace ::sd::slidesorter::controller;
 396
 397         if (pMasterPage == NULL)
 398             break;
 399
 400         // Find a visible slide sorter.
 401         SlideSorterViewShell* pSlideSorter = SlideSorterViewShell::GetSlideSorter(mrBase);
 402         if (pSlideSorter == NULL)
 403             break;
 404
 405         // Get a list of selected pages.
 406         ::sd::slidesorter::SharedPageSelection pPageSelection = pSlideSorter->GetPageSelection();
 407         if (pPageSelection->empty())
 408             break;
 409
 410         AssignMasterPageToPageList(pMasterPage, pPageSelection);
 411
 412         // Restore the previous selection.
 413         pSlideSorter->SetPageSelection(pPageSelection);
 414     }
 415     while (false);
 416 }
 417
 418
 419
 420
 421 void MasterPagesSelector::AssignMasterPageToPageList (
 422     SdPage* pMasterPage,
 423     const ::sd::slidesorter::SharedPageSelection& rPageList)
 424 {
 425     DocumentHelper::AssignMasterPageToPageList(mrDocument, pMasterPage, rPageList);
 426 }
 427
 428
 429
 430
 431 void MasterPagesSelector::NotifyContainerChangeEvent (const MasterPageContainerChangeEvent& rEvent)
 432 {
 433     const ::osl::MutexGuard aGuard (maMutex);
 434
 435     switch (rEvent.meEventType)
 436     {
 437         case MasterPageContainerChangeEvent::SIZE_CHANGED:
 438             mpPageSet->SetPreviewSize(mpContainer->GetPreviewSizePixel());
 439             UpdateAllPreviews();
 440             break;
 441
 442         case MasterPageContainerChangeEvent::PREVIEW_CHANGED:
 443         {
 444             int nIndex (GetIndexForToken(rEvent.maChildToken));
 445             if (nIndex >= 0)
 446             {
 447                 mpPageSet->SetItemImage (
 448                     (USHORT)nIndex,
 449                     mpContainer->GetPreviewForToken(rEvent.maChildToken));
 450                 mpPageSet->Invalidate(mpPageSet->GetItemRect((USHORT)nIndex));
 451             }
 452         }
 453         break;
 454
 455         case MasterPageContainerChangeEvent::DATA_CHANGED:
 456         {
 457             InvalidateItem(rEvent.maChildToken);
 458             Fill();
 459         }
 460         break;
 461
 462         default:
 463             break;
 464    }
 465 }
 466
 467
 468
 469
 470 MasterPagesSelector::UserData* MasterPagesSelector::CreateUserData (
 471     int nIndex,
 472     MasterPageContainer::Token aToken) const
 473 {
 474     return new UserData(nIndex,aToken);
 475 }
 476
 477
 478
 479
 480 MasterPagesSelector::UserData* MasterPagesSelector::GetUserData (int nIndex) const
 481 {
 482     const ::osl::MutexGuard aGuard (maMutex);
 483
 484     if (nIndex>0 && nIndex<=mpPageSet->GetItemCount())
 485         return reinterpret_cast<UserData*>(mpPageSet->GetItemData((USHORT)nIndex));
 486     else
 487         return NULL;
 488 }
 489
 490
 491
 492
 493 void MasterPagesSelector::SetUserData (int nIndex, UserData* pData)
 494 {
 495     const ::osl::MutexGuard aGuard (maMutex);
 496
 497     if (nIndex>0 && nIndex<=mpPageSet->GetItemCount())
 498     {
 499         UserData* pOldData = GetUserData(nIndex);
 500         if (pOldData!=NULL && pOldData!=pData)
 501             delete pOldData;
 502         mpPageSet->SetItemData((USHORT)nIndex, pData);
 503     }
 504 }
 505
 506
 507
 508
 509 bool MasterPagesSelector::IsResizable (void)
 510 {
 511     return false;
 512 }
 513
 514
 515
 516
 517 ::Window* MasterPagesSelector::GetWindow (void)
 518 {
 519     return mpPageSet.get();
 520 }
 521
 522
 523
 524
 525 sal_Int32 MasterPagesSelector::GetMinimumWidth (void)
 526 {
 527     return mpContainer->GetPreviewSizePixel().Width() + 2*3;
 528 }
 529
 530
 531
 532
 533 void MasterPagesSelector::UpdateSelection (void)
 534 {
 535 }
 536
 537
 538
 539
 540 void MasterPagesSelector::Execute (SfxRequest& rRequest)
 541 {
 542     switch (rRequest.GetSlot())
 543     {
 544         case SID_TP_APPLY_TO_ALL_SLIDES:
 545             mrBase.SetBusyState (true);
 546             AssignMasterPageToAllSlides (GetSelectedMasterPage());
 547             mrBase.SetBusyState (false);
 548             break;
 549
 550         case SID_TP_APPLY_TO_SELECTED_SLIDES:
 551             mrBase.SetBusyState (true);
 552             AssignMasterPageToSelectedSlides (GetSelectedMasterPage());
 553             mrBase.SetBusyState (false);
 554             break;
 555
 556         case SID_TP_USE_FOR_NEW_PRESENTATIONS:
 557             DBG_ASSERT (false,
 558                 "Using slides as default for new presentations"
 559                 " is not yet implemented");
 560             break;
 561
 562         case SID_TP_SHOW_SMALL_PREVIEW:
 563         case SID_TP_SHOW_LARGE_PREVIEW:
 564         {
 565             mrBase.SetBusyState (true);
 566             mpContainer->SetPreviewSize(
 567                 rRequest.GetSlot()==SID_TP_SHOW_SMALL_PREVIEW
 568                 ? MasterPageContainer::SMALL
 569                 : MasterPageContainer::LARGE);
 570             mrBase.SetBusyState (false);
 571             break;
 572         }
 573
 574         case SID_TP_EDIT_MASTER:
 575         {
 576             using namespace ::com::sun::star;
 577             uno::Reference<drawing::XDrawPage> xSelectedMaster (
 578                 GetSelectedMasterPage()->getUnoPage(), uno::UNO_QUERY);
 579             SfxViewFrame* pViewFrame = mrBase.GetViewFrame();
 580             if (pViewFrame != NULL && xSelectedMaster.is())
 581             {
 582                 SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher();
 583                 if (pDispatcher != NULL)
 584                 {
 585                     USHORT nIndex = mpPageSet->GetSelectItemId();
 586                     pDispatcher->Execute(SID_MASTERPAGE, SFX_CALLMODE_SYNCHRON);
 587                     mpPageSet->SelectItem (nIndex);
 588                     mrBase.GetDrawController().setCurrentPage(xSelectedMaster);
 589                 }
 590             }
 591             break;
 592         }
 593
 594         case SID_CUT:
 595         case SID_COPY:
 596         case SID_PASTE:
 597             // Cut, copy, and paste are not supported and thus are ignored.
 598             break;
 599     }
 600 }
 601
 602
 603
 604
 605 void MasterPagesSelector::GetState (SfxItemSet& rItemSet)
 606 {
 607     if (mpContainer->GetPreviewSize() == MasterPageContainer::SMALL)
 608         rItemSet.DisableItem (SID_TP_SHOW_SMALL_PREVIEW);
 609     else
 610         rItemSet.DisableItem (SID_TP_SHOW_LARGE_PREVIEW);
 611
 612     // Cut and paste is not supported so do not show the menu entries.
 613     rItemSet.DisableItem (SID_CUT);
 614     rItemSet.DisableItem (SID_COPY);
 615     rItemSet.DisableItem (SID_PASTE);
 616 }
 617
 618
 619
 620
 621 void MasterPagesSelector::SetItem (
 622     USHORT nIndex,
 623     MasterPageContainer::Token aToken)
 624 {
 625     const ::osl::MutexGuard aGuard (maMutex);
 626
 627     RemoveTokenToIndexEntry(nIndex,aToken);
 628
 629     if (nIndex > 0)
 630     {
 631         if (aToken != MasterPageContainer::NIL_TOKEN)
 632         {
 633             Image aPreview (mpContainer->GetPreviewForToken(aToken));
 634             MasterPageContainer::PreviewState eState (mpContainer->GetPreviewState(aToken));
 635
 636             if (aPreview.GetSizePixel().Width()>0)
 637             {
 638                 if (mpPageSet->GetItemPos(nIndex) != VALUESET_ITEM_NOTFOUND)
 639                 {
 640                     mpPageSet->SetItemImage(nIndex,aPreview);
 641                     mpPageSet->SetItemText(nIndex, mpContainer->GetPageNameForToken(aToken));
 642                 }
 643                 else
 644                 {
 645                     mpPageSet->InsertItem (
 646                         nIndex,
 647                         aPreview,
 648                         mpContainer->GetPageNameForToken(aToken),
 649                         nIndex);
 650                 }
 651                 SetUserData(nIndex, CreateUserData(nIndex,aToken));
 652
 653                 AddTokenToIndexEntry(nIndex,aToken);
 654             }
 655
 656             if (eState == MasterPageContainer::PS_CREATABLE)
 657                 mpContainer->RequestPreview(aToken);
 658         }
 659         else
 660         {
 661             mpPageSet->RemoveItem(nIndex);
 662         }
 663     }
 664
 665 }
 666
 667
 668
 669
 670 void MasterPagesSelector::AddTokenToIndexEntry (
 671     USHORT nIndex,
 672     MasterPageContainer::Token aToken)
 673 {
 674     const ::osl::MutexGuard aGuard (maMutex);
 675
 676     maTokenToValueSetIndex[aToken] = nIndex;
 677 }
 678
 679
 680
 681
 682 void MasterPagesSelector::RemoveTokenToIndexEntry (
 683     USHORT nIndex,
 684     MasterPageContainer::Token aNewToken)
 685 {
 686     const ::osl::MutexGuard aGuard (maMutex);
 687
 688     UserData* pData = GetUserData(nIndex);
 689     if (pData != NULL)
 690     {
 691         // Get the token that the index pointed to previously.
 692         MasterPageContainer::Token aOldToken (pData->second);
 693
 694         if (aNewToken != aOldToken
 695             && nIndex == GetIndexForToken(aOldToken))
 696         {
 697             maTokenToValueSetIndex[aOldToken] = 0;
 698         }
 699     }
 700 }
 701
 702
 703
 704
 705 void MasterPagesSelector::InvalidatePreview (MasterPageContainer::Token aToken)
 706 {
 707     const ::osl::MutexGuard aGuard (maMutex);
 708
 709     int nIndex (GetIndexForToken(aToken));
 710     if (nIndex > 0)
 711     {
 712         mpContainer->InvalidatePreview(aToken);
 713         mpContainer->RequestPreview(aToken);
 714     }
 715 }
 716
 717
 718
 719
 720 void MasterPagesSelector::InvalidatePreview (const SdPage* pPage)
 721 {
 722     const ::osl::MutexGuard aGuard (maMutex);
 723
 724     for (USHORT nIndex=1; nIndex<=mpPageSet->GetItemCount(); nIndex++)
 725     {
 726         UserData* pData = GetUserData(nIndex);
 727         if (pData != NULL)
 728         {
 729             MasterPageContainer::Token aToken (pData->second);
 730             if (pPage == mpContainer->GetPageObjectForToken(aToken,false))
 731             {
 732                 mpContainer->InvalidatePreview(aToken);
 733                 mpContainer->RequestPreview(aToken);
 734                 break;
 735             }
 736         }
 737     }
 738 }
 739
 740
 741
 742
 743 void MasterPagesSelector::InvalidateAllPreviews (void)
 744 {
 745     const ::osl::MutexGuard aGuard (maMutex);
 746
 747     for (USHORT nIndex=1; nIndex<=mpPageSet->GetItemCount(); nIndex++)
 748         InvalidatePreview(nIndex);
 749 }
 750
 751
 752
 753
 754 void MasterPagesSelector::UpdateAllPreviews (void)
 755 {
 756     const ::osl::MutexGuard aGuard (maMutex);
 757
 758     for (USHORT nIndex=1; nIndex<=mpPageSet->GetItemCount(); nIndex++)
 759     {
 760         UserData* pData = GetUserData(nIndex);
 761         if (pData != NULL)
 762         {
 763             MasterPageContainer::Token aToken (pData->second);
 764             mpPageSet->SetItemImage(
 765                 nIndex,
 766                 mpContainer->GetPreviewForToken(aToken));
 767             if (mpContainer->GetPreviewState(aToken) == MasterPageContainer::PS_CREATABLE)
 768                 mpContainer->RequestPreview(aToken);
 769         }
 770     }
 771     mpPageSet->Rearrange(true);
 772 }
 773
 774
 775
 776
 777 void MasterPagesSelector::ClearPageSet (void)
 778 {
 779     const ::osl::MutexGuard aGuard (maMutex);
 780
 781     for (USHORT nIndex=1; nIndex<=mpPageSet->GetItemCount(); nIndex++)
 782     {
 783         UserData* pData = GetUserData(nIndex);
 784         if (pData != NULL)
 785             delete pData;
 786     }
 787     mpPageSet->Clear();
 788 }
 789
 790
 791
 792
 793 void MasterPagesSelector::SetSmartHelpId( const SmartId& aId, SmartIdUpdateMode aMode )
 794 {
 795     const ::osl::MutexGuard aGuard (maMutex);
 796
 797     mpPageSet->SetSmartHelpId( aId, aMode );
 798 }
 799
 800
 801
 802
 803 sal_Int32 MasterPagesSelector::GetIndexForToken (MasterPageContainer::Token aToken) const
 804 {
 805     const ::osl::MutexGuard aGuard (maMutex);
 806
 807     TokenToValueSetIndex::const_iterator iIndex (maTokenToValueSetIndex.find(aToken));
 808     if (iIndex != maTokenToValueSetIndex.end())
 809         return iIndex->second;
 810     else
 811         return -1;
 812 }
 813
 814
 815
 816
 817 void MasterPagesSelector::Clear (void)
 818 {
 819     const ::osl::MutexGuard aGuard (maMutex);
 820
 821     ClearPageSet();
 822 }
 823
 824
 825
 826
 827 void MasterPagesSelector::InvalidateItem (MasterPageContainer::Token aToken)
 828 {
 829     const ::osl::MutexGuard aGuard (maMutex);
 830
 831     ItemList::iterator iItem;
 832     for (iItem=maCurrentItemList.begin(); iItem!=maCurrentItemList.end(); ++iItem)
 833     {
 834         if (*iItem == aToken)
 835         {
 836             *iItem = MasterPageContainer::NIL_TOKEN;
 837             break;
 838         }
 839     }
 840 }
 841
 842
 843
 844
 845 void MasterPagesSelector::UpdateItemList (::std::auto_ptr<ItemList> pNewItemList)
 846 {
 847     const ::osl::MutexGuard aGuard (maMutex);
 848
 849     ItemList::const_iterator iNewItem (pNewItemList->begin());
 850     ItemList::const_iterator iCurrentItem (maCurrentItemList.begin());
 851     ItemList::const_iterator iNewEnd (pNewItemList->end());
 852     ItemList::const_iterator iCurrentEnd (maCurrentItemList.end());
 853     USHORT nIndex (1);
 854
 855     // Update existing items.
 856     for ( ; iNewItem!=iNewEnd && iCurrentItem!=iCurrentEnd; ++iNewItem, ++iCurrentItem,++nIndex)
 857     {
 858         if (*iNewItem != *iCurrentItem)
 859         {
 860             SetItem(nIndex,*iNewItem);
 861         }
 862     }
 863
 864     // Append new items.
 865     for ( ; iNewItem!=iNewEnd; ++iNewItem,++nIndex)
 866     {
 867         SetItem(nIndex,*iNewItem);
 868     }
 869
 870     // Remove trailing items.
 871     for ( ; iCurrentItem!=iCurrentEnd; ++iCurrentItem,++nIndex)
 872     {
 873         SetItem(nIndex,MasterPageContainer::NIL_TOKEN);
 874     }
 875
 876     maCurrentItemList.swap(*pNewItemList);
 877
 878     mpPageSet->Rearrange();
 879     if (GetParentNode() != NULL)
 880         GetParentNode()->RequestResize();
 881 }
 882
 883
 884
 885
 886
 887 } } } // end of namespace ::sd::toolpanel::controls