sd/source/ui/func/fusumry.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 <fusumry.hxx>
  21 #include <editeng/eeitem.hxx>
  22 #include <svx/svdotext.hxx>
  23 #include <svx/svdundo.hxx>
  24 #include <editeng/outlobj.hxx>
  25 #include <xmloff/autolayout.hxx>
  26
  27 #include <strings.hrc>
  28
  29 #include <pres.hxx>
  30 #include <View.hxx>
  31 #include <sdpage.hxx>
  32 #include <Outliner.hxx>
  33 #include <drawdoc.hxx>
  34 #include <ViewShell.hxx>
  35 #include <sdmod.hxx>
  36 #include <sdresid.hxx>
  37 #include <DrawViewShell.hxx>
  38
  39 using namespace com::sun::star;
  40
  41 namespace sd {
  42
  43
  44 FuSummaryPage::FuSummaryPage (
  45     ViewShell* pViewSh,
  46     ::sd::Window* pWin,
  47     ::sd::View* pView,
  48     SdDrawDocument* pDoc,
  49     SfxRequest& rReq)
  50     : FuPoor(pViewSh, pWin, pView, pDoc, rReq)
  51 {
  52 }
  53
  54 rtl::Reference<FuPoor> FuSummaryPage::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
  55 {
  56     rtl::Reference<FuPoor> xFunc( new FuSummaryPage( pViewSh, pWin, pView, pDoc, rReq ) );
  57     xFunc->DoExecute(rReq);
  58     return xFunc;
  59 }
  60
  61 void FuSummaryPage::DoExecute( SfxRequest& )
  62 {
  63     std::unique_ptr<SdOutliner> pOutl;
  64     SdPage* pSummaryPage = nullptr;
  65     sal_uInt16 i = 0;
  66     sal_uInt16 nFirstPage = SDRPAGE_NOTFOUND;
  67     sal_uInt16 nSelectedPages = 0;
  68     sal_uInt16 nCount = mpDoc->GetSdPageCount(PageKind::Standard);
  69
  70     while (i < nCount && nSelectedPages <= 1)
  71     {
  72         /* How many pages are selected?
  73              exactly one: pool everything from this page
  74              otherwise:   only pool the selected pages  */
  75         SdPage* pActualPage = mpDoc->GetSdPage(i, PageKind::Standard);
  76
  77         if (pActualPage->IsSelected())
  78         {
  79             if (nFirstPage == SDRPAGE_NOTFOUND)
  80             {
  81                 nFirstPage = i;
  82             }
  83
  84             nSelectedPages++;
  85         }
  86
  87         i++;
  88     }
  89
  90     bool bBegUndo = false;
  91
  92     SfxStyleSheet* pStyle = nullptr;
  93
  94     for (i = nFirstPage; i < nCount; i++)
  95     {
  96         SdPage* pActualPage = mpDoc->GetSdPage(i, PageKind::Standard);
  97
  98         if (nSelectedPages <= 1 || pActualPage->IsSelected())
  99         {
 100             SdPage* pActualNotesPage = mpDoc->GetSdPage(i, PageKind::Notes);
 101             SdrTextObj* pTextObj = static_cast<SdrTextObj*>( pActualPage->GetPresObj(PRESOBJ_TITLE) );
 102
 103             if (pTextObj && !pTextObj->IsEmptyPresObj())
 104             {
 105                 if (!pSummaryPage)
 106                 {
 107                     // insert "table of content"-page and create outliner
 108                     const bool bUndo = mpView->IsUndoEnabled();
 109
 110                     if( bUndo )
 111                     {
 112                         mpView->BegUndo(SdResId(STR_UNDO_SUMMARY_PAGE));
 113                         bBegUndo = true;
 114                     }
 115
 116                     SdrLayerIDSet aVisibleLayers = pActualPage->TRG_GetMasterPageVisibleLayers();
 117
 118                     // page with title & structuring!
 119                     pSummaryPage = mpDoc->AllocSdPage(false);
 120                     pSummaryPage->SetSize(pActualPage->GetSize() );
 121                     pSummaryPage->SetBorder(pActualPage->GetLeftBorder(),
 122                                      pActualPage->GetUpperBorder(),
 123                                      pActualPage->GetRightBorder(),
 124                                      pActualPage->GetLowerBorder() );
 125
 126                     // insert page at the back
 127                     mpDoc->InsertPage(pSummaryPage, nCount * 2 + 1);
 128                     if( bUndo )
 129                         mpView->AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pSummaryPage));
 130
 131                     // use MasterPage of the current page
 132                     pSummaryPage->TRG_SetMasterPage(pActualPage->TRG_GetMasterPage());
 133                     pSummaryPage->SetLayoutName(pActualPage->GetLayoutName());
 134                     pSummaryPage->SetAutoLayout(AUTOLAYOUT_TITLE_CONTENT, true);
 135                     pSummaryPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
 136                     pSummaryPage->setHeaderFooterSettings(pActualPage->getHeaderFooterSettings());
 137
 138                     // notes-page
 139                     SdPage* pNotesPage = mpDoc->AllocSdPage(false);
 140                     pNotesPage->SetSize(pActualNotesPage->GetSize());
 141                     pNotesPage->SetBorder(pActualNotesPage->GetLeftBorder(),
 142                                           pActualNotesPage->GetUpperBorder(),
 143                                           pActualNotesPage->GetRightBorder(),
 144                                           pActualNotesPage->GetLowerBorder() );
 145                     pNotesPage->SetPageKind(PageKind::Notes);
 146
 147                     // insert page at the back
 148                     mpDoc->InsertPage(pNotesPage, nCount * 2 + 2);
 149
 150                     if( bUndo )
 151                         mpView->AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pNotesPage));
 152
 153                     // use MasterPage of the current page
 154                     pNotesPage->TRG_SetMasterPage(pActualNotesPage->TRG_GetMasterPage());
 155                     pNotesPage->SetLayoutName(pActualNotesPage->GetLayoutName());
 156                     pNotesPage->SetAutoLayout(pActualNotesPage->GetAutoLayout(), true);
 157                     pNotesPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
 158                     pNotesPage->setHeaderFooterSettings(pActualNotesPage->getHeaderFooterSettings());
 159
 160                     pOutl.reset(new SdOutliner( mpDoc, OutlinerMode::OutlineObject ));
 161                     pOutl->SetUpdateMode(false);
 162                     pOutl->EnableUndo(false);
 163
 164                     if (mpDocSh)
 165                         pOutl->SetRefDevice(SD_MOD()->GetVirtualRefDevice());
 166
 167                     pOutl->SetDefTab( mpDoc->GetDefaultTabulator() );
 168                     pOutl->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(mpDoc->GetStyleSheetPool()));
 169                     pStyle = pSummaryPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE );
 170                     pOutl->SetStyleSheet( 0, pStyle );
 171                 }
 172
 173                 // add text
 174                 OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
 175                 // #118876#, check if the OutlinerParaObject is created successfully
 176                 if( pParaObj )
 177                 {
 178                     pParaObj->SetOutlinerMode( OutlinerMode::OutlineObject );
 179                     pOutl->AddText(*pParaObj);
 180                 }
 181             }
 182         }
 183     }
 184
 185     if (!pSummaryPage)
 186         return;
 187
 188     SdrTextObj* pTextObj = static_cast<SdrTextObj*>( pSummaryPage->GetPresObj(PRESOBJ_OUTLINE) );
 189
 190     if (!pTextObj)
 191         return;
 192
 193     // remove hard break- and character attributes
 194     SfxItemSet aEmptyEEAttr(mpDoc->GetPool(), svl::Items<EE_ITEMS_START, EE_ITEMS_END>{});
 195     sal_Int32 nParaCount = pOutl->GetParagraphCount();
 196
 197     for (sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
 198     {
 199         pOutl->SetStyleSheet( nPara, pStyle );
 200         pOutl->RemoveCharAttribs(nPara);
 201         pOutl->SetParaAttribs(nPara, aEmptyEEAttr);
 202         pOutl->SetDepth(pOutl->GetParagraph(nPara), 0);
 203     }
 204
 205     pTextObj->SetOutlinerParaObject( pOutl->CreateParaObject() );
 206     pTextObj->SetEmptyPresObj(false);
 207
 208     // remove hard attributes (Flag to sal_True)
 209     SfxItemSet aAttr(mpDoc->GetPool());
 210     aAttr.Put(XLineStyleItem(drawing::LineStyle_NONE));
 211     aAttr.Put(XFillStyleItem(drawing::FillStyle_NONE));
 212     pTextObj->SetMergedItemSet(aAttr);
 213
 214     if( bBegUndo )
 215         mpView->EndUndo();
 216     pOutl.reset();
 217
 218     DrawViewShell* pDrawViewShell= dynamic_cast< DrawViewShell* >( mpViewShell );
 219     if(pDrawViewShell)
 220     {
 221         pDrawViewShell->SwitchPage( (pSummaryPage->GetPageNum() - 1) / 2);
 222     }
 223 }
 224
 225 } // end of namespace sd
 226
 227 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */