sd/source/ui/sidebar/CurrentMasterPagesSelector.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 "CurrentMasterPagesSelector.hxx"
  21 #include "PreviewValueSet.hxx"
  22 #include <ViewShellBase.hxx>
  23 #include <DrawViewShell.hxx>
  24 #include <drawdoc.hxx>
  25 #include <sdpage.hxx>
  26 #include "MasterPageContainer.hxx"
  27 #include "MasterPageDescriptor.hxx"
  28 #include <EventMultiplexer.hxx>
  29 #include <app.hrc>
  30 #include <DrawDocShell.hxx>
  31
  32 #include <helpids.h>
  33
  34 #include <vcl/image.hxx>
  35 #include <svx/svdmodel.hxx>
  36 #include <sfx2/request.hxx>
  37
  38 #include <set>
  39
  40 using namespace ::com::sun::star;
  41
  42 namespace sd { namespace sidebar {
  43
  44 VclPtr<vcl::Window> CurrentMasterPagesSelector::Create (
  45     vcl::Window* pParent,
  46     ViewShellBase& rViewShellBase,
  47     const css::uno::Reference<css::ui::XSidebar>& rxSidebar)
  48 {
  49     SdDrawDocument* pDocument = rViewShellBase.GetDocument();
  50     if (pDocument == nullptr)
  51         return nullptr;
  52
  53     std::shared_ptr<MasterPageContainer> pContainer (new MasterPageContainer());
  54
  55     VclPtrInstance<CurrentMasterPagesSelector> pSelector(
  56             pParent,
  57             *pDocument,
  58             rViewShellBase,
  59             pContainer,
  60             rxSidebar);
  61     pSelector->LateInit();
  62     pSelector->SetHelpId( HID_SD_TASK_PANE_PREVIEW_CURRENT );
  63
  64     return pSelector;
  65 }
  66
  67 CurrentMasterPagesSelector::CurrentMasterPagesSelector (
  68     vcl::Window* pParent,
  69     SdDrawDocument& rDocument,
  70     ViewShellBase& rBase,
  71     const std::shared_ptr<MasterPageContainer>& rpContainer,
  72     const css::uno::Reference<css::ui::XSidebar>& rxSidebar)
  73     : MasterPagesSelector (pParent, rDocument, rBase, rpContainer, rxSidebar)
  74 {
  75     Link<sd::tools::EventMultiplexerEvent&,void> aLink (LINK(this,CurrentMasterPagesSelector,EventMultiplexerListener));
  76     rBase.GetEventMultiplexer()->AddEventListener(aLink);
  77 }
  78
  79 CurrentMasterPagesSelector::~CurrentMasterPagesSelector()
  80 {
  81     disposeOnce();
  82 }
  83
  84 void CurrentMasterPagesSelector::dispose()
  85 {
  86     if (mrDocument.GetDocSh() != nullptr)
  87     {
  88         EndListening(*mrDocument.GetDocSh());
  89     }
  90     else
  91     {
  92         OSL_ASSERT(mrDocument.GetDocSh() != nullptr);
  93     }
  94
  95     Link<sd::tools::EventMultiplexerEvent&,void> aLink (LINK(this,CurrentMasterPagesSelector,EventMultiplexerListener));
  96     mrBase.GetEventMultiplexer()->RemoveEventListener(aLink);
  97
  98     MasterPagesSelector::dispose();
  99 }
 100
 101 void CurrentMasterPagesSelector::LateInit()
 102 {
 103     MasterPagesSelector::LateInit();
 104     MasterPagesSelector::Fill();
 105     if (mrDocument.GetDocSh() != nullptr)
 106     {
 107         StartListening(*mrDocument.GetDocSh());
 108     }
 109     else
 110     {
 111         OSL_ASSERT(mrDocument.GetDocSh() != nullptr);
 112     }
 113 }
 114
 115 void CurrentMasterPagesSelector::Fill (ItemList& rItemList)
 116 {
 117     sal_uInt16 nPageCount = mrDocument.GetMasterSdPageCount(PageKind::Standard);
 118     // Remember the names of the master pages that have been inserted to
 119     // avoid double insertion.
 120     ::std::set<OUString> aMasterPageNames;
 121     for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++)
 122     {
 123         SdPage* pMasterPage = mrDocument.GetMasterSdPage (nIndex, PageKind::Standard);
 124         if (pMasterPage == nullptr)
 125             continue;
 126
 127         // Use the name of the master page to avoid duplicate entries.
 128         OUString sName (pMasterPage->GetName());
 129         if (aMasterPageNames.find(sName)!=aMasterPageNames.end())
 130             continue;
 131         aMasterPageNames.insert (sName);
 132
 133         // Look up the master page in the container and, when it is not yet
 134         // in it, insert it.
 135         MasterPageContainer::Token aToken = mpContainer->GetTokenForPageObject(pMasterPage);
 136         if (aToken == MasterPageContainer::NIL_TOKEN)
 137         {
 138             SharedMasterPageDescriptor pDescriptor (new MasterPageDescriptor(
 139                 MasterPageContainer::MASTERPAGE,
 140                 nIndex,
 141                 OUString(),
 142                 pMasterPage->GetName(),
 143                 OUString(),
 144                 pMasterPage->IsPrecious(),
 145                 std::shared_ptr<PageObjectProvider>(new ExistingPageProvider(pMasterPage)),
 146                 std::shared_ptr<PreviewProvider>(new PagePreviewProvider())));
 147             aToken = mpContainer->PutMasterPage(pDescriptor);
 148         }
 149
 150         rItemList.push_back(aToken);
 151     }
 152 }
 153
 154 OUString CurrentMasterPagesSelector::GetContextMenuUIFile() const
 155 {
 156     return OUString("modules/simpress/ui/currentmastermenu.ui");
 157 }
 158
 159 void CurrentMasterPagesSelector::UpdateSelection()
 160 {
 161     // Iterate over all pages and for the selected ones put the name of
 162     // their master page into a set.
 163     sal_uInt16 nPageCount = mrDocument.GetSdPageCount(PageKind::Standard);
 164     ::std::set<OUString> aNames;
 165     sal_uInt16 nIndex;
 166     bool bLoop (true);
 167     for (nIndex=0; nIndex<nPageCount && bLoop; nIndex++)
 168     {
 169         SdPage* pPage = mrDocument.GetSdPage (nIndex, PageKind::Standard);
 170         if (pPage != nullptr && pPage->IsSelected())
 171         {
 172             if ( ! pPage->TRG_HasMasterPage())
 173             {
 174                 // One of the pages has no master page.  This is an
 175                 // indicator for that this method is called in the middle of
 176                 // a document change and that the model is not in a valid
 177                 // state.  Therefore we stop update the selection and wait
 178                 // for another call to UpdateSelection when the model is
 179                 // valid again.
 180                 bLoop = false;
 181             }
 182             else
 183             {
 184                 SdrPage& rMasterPage (pPage->TRG_GetMasterPage());
 185                 SdPage* pMasterPage = static_cast<SdPage*>(&rMasterPage);
 186                 if (pMasterPage != nullptr)
 187                     aNames.insert (pMasterPage->GetName());
 188             }
 189         }
 190     }
 191
 192     // Find the items for the master pages in the set.
 193     sal_uInt16 nItemCount (PreviewValueSet::GetItemCount());
 194     for (nIndex=1; nIndex<=nItemCount && bLoop; nIndex++)
 195     {
 196         OUString sName (PreviewValueSet::GetItemText (nIndex));
 197         if (aNames.find(sName) != aNames.end())
 198         {
 199             PreviewValueSet::SelectItem (nIndex);
 200         }
 201     }
 202 }
 203
 204 void CurrentMasterPagesSelector::ExecuteCommand(const OString &rIdent)
 205 {
 206     if (rIdent == "delete")
 207     {
 208         // Check once again that the master page can safely be deleted,
 209         // i.e. is not used.
 210         SdPage* pMasterPage = GetSelectedMasterPage();
 211         if (pMasterPage != nullptr
 212             && mrDocument.GetMasterPageUserCount(pMasterPage) == 0)
 213         {
 214             // Removing the precious flag so that the following call to
 215             // RemoveUnnessesaryMasterPages() will remove this master page.
 216             pMasterPage->SetPrecious(false);
 217             mrDocument.RemoveUnnecessaryMasterPages(pMasterPage);
 218         }
 219     }
 220     else
 221         MasterPagesSelector::ExecuteCommand(rIdent);
 222 }
 223
 224 void CurrentMasterPagesSelector::ProcessPopupMenu (Menu& rMenu)
 225 {
 226     // Disable the delete entry when there is only one master page.
 227     if (mrDocument.GetMasterPageUserCount(GetSelectedMasterPage()) > 0)
 228     {
 229         sal_uInt16 nItemid = rMenu.GetItemId("delete");
 230         if (rMenu.GetItemPos(nItemid) != MENU_ITEM_NOTFOUND)
 231             rMenu.EnableItem(nItemid, false);
 232     }
 233
 234     std::shared_ptr<DrawViewShell> pDrawViewShell (
 235         std::dynamic_pointer_cast<DrawViewShell>(mrBase.GetMainViewShell()));
 236     if (pDrawViewShell
 237         && pDrawViewShell->GetEditMode() == EditMode::MasterPage)
 238     {
 239         sal_uInt16 nItemid = rMenu.GetItemId("edit");
 240         if (rMenu.GetItemPos(nItemid) != MENU_ITEM_NOTFOUND)
 241             rMenu.EnableItem(nItemid, false);
 242     }
 243
 244     MasterPagesSelector::ProcessPopupMenu(rMenu);
 245 }
 246
 247 IMPL_LINK(CurrentMasterPagesSelector,EventMultiplexerListener,
 248     sd::tools::EventMultiplexerEvent&, rEvent, void)
 249 {
 250     switch (rEvent.meEventId)
 251     {
 252         case EventMultiplexerEventId::CurrentPageChanged:
 253         case EventMultiplexerEventId::EditModeNormal:
 254         case EventMultiplexerEventId::EditModeMaster:
 255         case EventMultiplexerEventId::SlideSortedSelection:
 256             UpdateSelection();
 257             break;
 258
 259         case EventMultiplexerEventId::PageOrder:
 260             // This is tricky.  If a master page is removed, moved, or
 261             // added we have to wait until both the notes master page
 262             // and the standard master page have been removed, moved,
 263             // or added.  We do this by looking at the number of master
 264             // pages which has to be odd in the consistent state (the
 265             // handout master page is always present).  If the number is
 266             // even we ignore the hint.
 267             if (mrBase.GetDocument()->GetMasterPageCount()%2 == 1)
 268                 MasterPagesSelector::Fill();
 269             break;
 270
 271         case EventMultiplexerEventId::ShapeChanged:
 272         case EventMultiplexerEventId::ShapeInserted:
 273         case EventMultiplexerEventId::ShapeRemoved:
 274             InvalidatePreview(static_cast<const SdPage*>(rEvent.mpUserData));
 275             break;
 276         default: break;
 277     }
 278 }
 279
 280 } } // end of namespace sd::sidebar
 281
 282 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */