summaryrefslogtreecommitdiffstats
path: root/sd/source/core/sdpage.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'sd/source/core/sdpage.cxx')
-rw-r--r--sd/source/core/sdpage.cxx3157
1 files changed, 3157 insertions, 0 deletions
diff --git a/sd/source/core/sdpage.cxx b/sd/source/core/sdpage.cxx
new file mode 100644
index 000000000..38318f294
--- /dev/null
+++ b/sd/source/core/sdpage.cxx
@@ -0,0 +1,3157 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <algorithm>
+#include <array>
+
+#include <comphelper/classids.hxx>
+#include <comphelper/embeddedobjectcontainer.hxx>
+
+#include <sfx2/viewsh.hxx>
+#include <vcl/svapp.hxx>
+#include <editeng/outliner.hxx>
+#include <editeng/eeitem.hxx>
+#include <svx/svdoutl.hxx>
+#include <editeng/editdata.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/bulletitem.hxx>
+#include <svx/svdpagv.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/outlobj.hxx>
+#include <svx/svdoole2.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/svdopage.hxx>
+#include <editeng/pbinitem.hxx>
+#include <svx/svdundo.hxx>
+#include <svl/hint.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/editobj.hxx>
+#include <svx/unopage.hxx>
+#include <editeng/flditem.hxx>
+#include <svx/sdr/contact/displayinfo.hxx>
+#include <svx/svditer.hxx>
+#include <svx/svdlayer.hxx>
+#include <svx/sdtmfitm.hxx>
+#include <svx/sdtagitm.hxx>
+#include <svx/sdtcfitm.hxx>
+#include <svx/xfillit0.hxx>
+#include <tools/diagnose_ex.h>
+#include <com/sun/star/animations/XAnimationNode.hpp>
+#include <com/sun/star/animations/XTimeContainer.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/xml/dom/XNode.hpp>
+#include <com/sun/star/xml/dom/XNodeList.hpp>
+#include <com/sun/star/xml/dom/XNamedNodeMap.hpp>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <o3tl/enumarray.hxx>
+#include <o3tl/safeint.hxx>
+#include <o3tl/sorted_vector.hxx>
+#include <xmloff/autolayout.hxx>
+
+#include <Outliner.hxx>
+#include <app.hrc>
+#include <createunopageimpl.hxx>
+#include <drawdoc.hxx>
+#include <sdmod.hxx>
+#include <sdpage.hxx>
+#include <sdresid.hxx>
+#include <stlsheet.hxx>
+#include <strings.hrc>
+#include <strings.hxx>
+#include <bitmaps.hlst>
+#include <glob.hxx>
+#include <anminfo.hxx>
+#include <undo/undomanager.hxx>
+#include <undo/undoobjects.hxx>
+#include <svx/sdr/contact/viewobjectcontact.hxx>
+#include <svx/sdr/contact/viewcontact.hxx>
+#include <svx/sdr/contact/objectcontact.hxx>
+#include <svx/unoapi.hxx>
+#include <unokywds.hxx>
+
+using namespace ::sd;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace com::sun::star::xml::dom;
+using ::com::sun::star::uno::Reference;
+
+
+sal_uInt16 SdPage::mnLastPageId = 1;
+
+/*************************************************************************
+|*
+|* Ctor
+|*
+\************************************************************************/
+
+SdPage::SdPage(SdDrawDocument& rNewDoc, bool bMasterPage)
+: FmFormPage(rNewDoc, bMasterPage)
+, SdrObjUserCall()
+, mePageKind(PageKind::Standard)
+, meAutoLayout(AUTOLAYOUT_NONE)
+, mbSelected(false)
+, mePresChange(PresChange::Manual)
+, mfTime(1.0)
+, mbSoundOn(false)
+, mbExcluded(false)
+, mbLoopSound(false)
+, mbStopSound(false)
+, mbScaleObjects(true)
+, meCharSet(osl_getThreadTextEncoding())
+, mnPaperBin(PAPERBIN_PRINTER_SETTINGS)
+, mpPageLink(nullptr)
+, mnTransitionType(0)
+, mnTransitionSubtype(0)
+, mbTransitionDirection(true)
+, mnTransitionFadeColor(0)
+, mfTransitionDuration(2.0)
+, mbIsPrecious(true)
+, mnPageId(mnLastPageId++)
+{
+ // The name of the layout of the page is used by SVDRAW to determine the
+ // presentation template of the outline objects. Therefore, it already
+ // contains the designator for the outline (STR_LAYOUT_OUTLINE).
+ maLayoutName = SdResId(STR_LAYOUT_DEFAULT_NAME)+ SD_LT_SEPARATOR + STR_LAYOUT_OUTLINE;
+
+ // Stuff that former SetModel did also:
+ ConnectLink();
+}
+
+namespace
+{
+ void clearChildNodes(css::uno::Reference<css::animations::XAnimationNode> const & rAnimationNode)
+ {
+ css::uno::Reference<css::container::XEnumerationAccess > xEnumerationAccess(rAnimationNode, UNO_QUERY);
+ if (!xEnumerationAccess.is())
+ return;
+ css::uno::Reference<css::container::XEnumeration> xEnumeration = xEnumerationAccess->createEnumeration();
+ if (!xEnumeration.is())
+ return;
+ while (xEnumeration->hasMoreElements())
+ {
+ css::uno::Reference<css::animations::XAnimationNode> xChildNode(xEnumeration->nextElement(), UNO_QUERY);
+ if (!xChildNode.is())
+ continue;
+ clearChildNodes(xChildNode);
+ css::uno::Reference<css::animations::XTimeContainer> xAnimationNode(rAnimationNode, UNO_QUERY);
+ if (!xAnimationNode.is())
+ {
+ SAL_WARN("sd.core", "can't remove node child, possible leak");
+ continue;
+ }
+ xAnimationNode->removeChild(xChildNode);
+ }
+ }
+}
+
+/*************************************************************************
+|*
+|* Dtor
+|*
+\************************************************************************/
+
+SdPage::~SdPage()
+{
+ DisconnectLink();
+
+ EndListenOutlineText();
+
+ clearChildNodes(mxAnimationNode);
+
+ // disconnect the UserCall link
+ SdrObjListIter aIter( this, SdrIterMode::DeepWithGroups );
+ while( aIter.IsMore() )
+ {
+ SdrObject* pChild = aIter.Next();
+ if( pChild->GetUserCall() == this )
+ pChild->SetUserCall(nullptr);
+ }
+
+ // clear SdrObjects with broadcasting
+ ClearSdrObjList();
+}
+
+namespace {
+
+struct OrdNumSorter
+{
+ bool operator()( SdrObject const * p1, SdrObject const * p2 )
+ {
+ return p1->GetOrdNum() < p2->GetOrdNum();
+ }
+};
+
+}
+
+/** returns the nIndex'th object from the given PresObjKind, index starts with 1 */
+SdrObject* SdPage::GetPresObj(PresObjKind eObjKind, int nIndex, bool bFuzzySearch /* = false */ )
+{
+ // first sort all matching shapes with z-order
+ std::vector< SdrObject* > aMatches;
+
+ SdrObject* pObj = nullptr;
+ maPresentationShapeList.seekShape(0);
+
+ while( (pObj = maPresentationShapeList.getNextShape()) )
+ {
+ SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj);
+ if( pInfo )
+ {
+ bool bFound = false;
+ if( pInfo->mePresObjKind == eObjKind )
+ {
+ bFound = true;
+ }
+ else if( bFuzzySearch && (eObjKind == PresObjKind::Outline) )
+ {
+ switch( pInfo->mePresObjKind )
+ {
+ case PresObjKind::Graphic:
+ case PresObjKind::Object:
+ case PresObjKind::Chart:
+ case PresObjKind::OrgChart:
+ case PresObjKind::Table:
+ case PresObjKind::Calc:
+ case PresObjKind::Media:
+ bFound = true;
+ break;
+ default:
+ break;
+ }
+ }
+ if( bFound )
+ {
+ aMatches.push_back( pObj );
+ }
+ }
+ }
+
+ if( nIndex > 0 )
+ nIndex--;
+
+ if( (nIndex >= 0) && ( aMatches.size() > o3tl::make_unsigned(nIndex)) )
+ {
+ if( aMatches.size() > 1 )
+ std::nth_element( aMatches.begin(), aMatches.begin() + nIndex, aMatches.end(),
+ OrdNumSorter() );
+ return aMatches[nIndex];
+ }
+
+ return nullptr;
+}
+
+/** create background properties */
+void SdPage::EnsureMasterPageDefaultBackground()
+{
+ if(!mbMaster)
+ return;
+
+ // no hard attributes on MasterPage attributes
+ getSdrPageProperties().ClearItem();
+ SfxStyleSheet* pSheetForPresObj = GetStyleSheetForMasterPageBackground();
+
+ if(pSheetForPresObj)
+ {
+ // set StyleSheet for background fill attributes
+ getSdrPageProperties().SetStyleSheet(pSheetForPresObj);
+ }
+ else
+ {
+ // no style found, assert and set at least drawing::FillStyle_NONE
+ OSL_FAIL("No Style for MasterPageBackground fill found (!)");
+ getSdrPageProperties().PutItem(XFillStyleItem(drawing::FillStyle_NONE));
+ }
+}
+
+/** creates a presentation object with the given PresObjKind on this page. A user call will be set
+*/
+SdrObject* SdPage::CreatePresObj(PresObjKind eObjKind, bool bVertical, const ::tools::Rectangle& rRect )
+{
+ SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager());
+ const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
+
+ SdrObject* pSdrObj = nullptr;
+
+ bool bForceText = false; // forces the shape text to be set even if it's empty
+ bool bEmptyPresObj = true;
+
+ switch( eObjKind )
+ {
+ case PresObjKind::Title:
+ {
+ pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::TitleText);
+
+ if (mbMaster)
+ {
+ pSdrObj->SetNotVisibleAsMaster(true);
+ }
+ }
+ break;
+
+ case PresObjKind::Outline:
+ {
+ pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::OutlineText);
+
+ if (mbMaster)
+ {
+ pSdrObj->SetNotVisibleAsMaster(true);
+ }
+ }
+ break;
+
+ case PresObjKind::Notes:
+ {
+ pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
+
+ if (mbMaster)
+ {
+ pSdrObj->SetNotVisibleAsMaster(true);
+ }
+ }
+ break;
+
+ case PresObjKind::Text:
+ {
+ pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
+ }
+ break;
+
+ case PresObjKind::Graphic:
+ {
+ BitmapEx aBmpEx(BMP_PRESOBJ_GRAPHIC);
+ Graphic aGraphic( aBmpEx );
+ OutputDevice &aOutDev = *Application::GetDefaultDevice();
+ aOutDev.Push();
+
+ aOutDev.SetMapMode( aGraphic.GetPrefMapMode() );
+ Size aSizePix = aOutDev.LogicToPixel( aGraphic.GetPrefSize() );
+ aOutDev.SetMapMode(MapMode(MapUnit::Map100thMM));
+
+ Size aSize = aOutDev.PixelToLogic(aSizePix);
+ Point aPnt (0, 0);
+ ::tools::Rectangle aRect (aPnt, aSize);
+ pSdrObj = new SdrGrafObj(getSdrModelFromSdrPage(), aGraphic, aRect);
+ aOutDev.Pop();
+ }
+ break;
+
+ case PresObjKind::Media:
+ case PresObjKind::Object:
+ {
+ pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage());
+ BitmapEx aBmpEx(BMP_PRESOBJ_OBJECT);
+ Graphic aGraphic( aBmpEx );
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetGraphic(aGraphic);
+ }
+ break;
+
+ case PresObjKind::Chart:
+ {
+ pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage());
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetProgName( "StarChart" );
+ BitmapEx aBmpEx(BMP_PRESOBJ_CHART);
+ Graphic aGraphic( aBmpEx );
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetGraphic(aGraphic);
+ }
+ break;
+
+ case PresObjKind::OrgChart:
+ {
+ pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage());
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetProgName( "StarOrg" );
+ BitmapEx aBmpEx(BMP_PRESOBJ_ORGCHART);
+ Graphic aGraphic( aBmpEx );
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetGraphic(aGraphic);
+ }
+ break;
+
+ case PresObjKind::Table:
+ case PresObjKind::Calc:
+ {
+ pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage());
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetProgName( "StarCalc" );
+ BitmapEx aBmpEx(BMP_PRESOBJ_TABLE);
+ Graphic aGraphic( aBmpEx );
+ static_cast<SdrOle2Obj*>(pSdrObj)->SetGraphic(aGraphic);
+ }
+ break;
+
+ case PresObjKind::Handout:
+ {
+ // Save the first standard page at SdrPageObj
+ // #i105146# We want no content to be displayed for PageKind::Handout,
+ // so just never set a page as content
+ pSdrObj = new SdrPageObj(getSdrModelFromSdrPage(), nullptr);
+ }
+ break;
+
+ case PresObjKind::Page:
+ {
+ // Save note pages at SdrPageObj
+ sal_uInt16 nDestPageNum(GetPageNum());
+
+ if(nDestPageNum)
+ {
+ // decrement only when != 0, else we get a 0xffff
+ nDestPageNum -= 1;
+ }
+
+ if (nDestPageNum < getSdrModelFromSdrPage().GetPageCount())
+ {
+ pSdrObj = new SdrPageObj(getSdrModelFromSdrPage(), getSdrModelFromSdrPage().GetPage(nDestPageNum));
+ }
+ else
+ {
+ pSdrObj = new SdrPageObj(getSdrModelFromSdrPage());
+ }
+
+ pSdrObj->SetResizeProtect(true);
+ }
+ break;
+
+ case PresObjKind::Header:
+ case PresObjKind::Footer:
+ case PresObjKind::DateTime:
+ case PresObjKind::SlideNumber:
+ {
+ pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
+ bEmptyPresObj = false;
+ bForceText = true;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (pSdrObj)
+ {
+ pSdrObj->SetEmptyPresObj(bEmptyPresObj);
+ pSdrObj->SetLogicRect(rRect);
+
+ InsertObject(pSdrObj);
+
+ if ( auto pTextObj = dynamic_cast<SdrTextObj *>( pSdrObj ) )
+ {
+ // Tell the object EARLY that it is vertical to have the
+ // defaults for AutoGrowWidth/Height reversed
+ if(bVertical)
+ pTextObj->SetVerticalWriting(true);
+
+ SfxItemSet aTempAttr(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool());
+ if( bVertical )
+ aTempAttr.Put( makeSdrTextMinFrameWidthItem( rRect.GetSize().Width() ) );
+ else
+ aTempAttr.Put( makeSdrTextMinFrameHeightItem( rRect.GetSize().Height() ) );
+
+ if (mbMaster)
+ {
+ // The size of presentation objects on the master page have to
+ // be freely selectable by the user.
+
+ // potential problem: This action was still NOT
+ // adapted for vertical text. This sure needs to be done.
+ if(bVertical)
+ aTempAttr.Put(makeSdrTextAutoGrowWidthItem(false));
+ else
+ aTempAttr.Put(makeSdrTextAutoGrowHeightItem(false));
+ }
+
+ // check if we need another vertical adjustment than the default
+ SdrTextVertAdjust eV = SDRTEXTVERTADJUST_TOP;
+
+ if( (eObjKind == PresObjKind::Footer) && (mePageKind != PageKind::Standard) )
+ {
+ eV = SDRTEXTVERTADJUST_BOTTOM;
+ }
+ else if( (eObjKind == PresObjKind::SlideNumber) && (mePageKind != PageKind::Standard) )
+ {
+ eV = SDRTEXTVERTADJUST_BOTTOM;
+ }
+
+ if( eV != SDRTEXTVERTADJUST_TOP )
+ aTempAttr.Put(SdrTextVertAdjustItem(eV));
+
+ pSdrObj->SetMergedItemSet(aTempAttr);
+
+ pSdrObj->SetLogicRect(rRect);
+ }
+
+ OUString aString = GetPresObjText(eObjKind);
+ if(!aString.isEmpty() || bForceText)
+ if (auto pTextObj = dynamic_cast<SdrTextObj *>( pSdrObj ) )
+ {
+ SdrOutliner* pOutliner = static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetInternalOutliner();
+
+ OutlinerMode nOutlMode = pOutliner->GetOutlinerMode();
+ pOutliner->Init( OutlinerMode::TextObject );
+ pOutliner->SetStyleSheet( 0, nullptr );
+ pOutliner->SetVertical( bVertical );
+
+ SetObjText( pTextObj, pOutliner, eObjKind, aString );
+
+ pOutliner->Init( nOutlMode );
+ pOutliner->SetStyleSheet( 0, nullptr );
+ }
+
+ if( (eObjKind == PresObjKind::Header) || (eObjKind == PresObjKind::Footer) || (eObjKind == PresObjKind::SlideNumber) || (eObjKind == PresObjKind::DateTime) )
+ {
+ SfxItemSet aTempAttr(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool());
+ aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT ) );
+ aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CTL ) );
+ aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CJK ) );
+
+ SvxAdjust eH = SvxAdjust::Left;
+
+ if( (eObjKind == PresObjKind::DateTime) && (mePageKind != PageKind::Standard ) )
+ {
+ eH = SvxAdjust::Right;
+ }
+ else if( (eObjKind == PresObjKind::Footer) && (mePageKind == PageKind::Standard ) )
+ {
+ eH = SvxAdjust::Center;
+ }
+ else if( eObjKind == PresObjKind::SlideNumber )
+ {
+ eH = SvxAdjust::Right;
+ }
+
+ if( eH != SvxAdjust::Left )
+ aTempAttr.Put(SvxAdjustItem(eH, EE_PARA_JUST ));
+
+ pSdrObj->SetMergedItemSet(aTempAttr);
+ }
+
+ if (mbMaster)
+ {
+ SdrLayerAdmin& rLayerAdmin(getSdrModelFromSdrPage().GetLayerAdmin());
+
+ // background objects of the master page
+ pSdrObj->SetLayer( rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects) );
+ }
+
+ // Subscribe object at the style sheet
+ // Set style only when one was found (as in 5.2)
+ if( mePageKind != PageKind::Handout )
+ {
+ SfxStyleSheet* pSheetForPresObj = GetStyleSheetForPresObj(eObjKind);
+ if(pSheetForPresObj)
+ pSdrObj->SetStyleSheet(pSheetForPresObj, false);
+ }
+
+ if (eObjKind == PresObjKind::Outline)
+ {
+ for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++)
+ {
+ OUString aName( maLayoutName + " " + OUString::number( nLevel ) );
+ SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>(getSdrModelFromSdrPage().GetStyleSheetPool()->Find(aName, SfxStyleFamily::Page));
+ DBG_ASSERT(pSheet, "StyleSheet for outline object not found");
+ if (pSheet)
+ pSdrObj->StartListening(*pSheet, DuplicateHandling::Allow);
+ }
+ }
+
+ if ( eObjKind == PresObjKind::Object ||
+ eObjKind == PresObjKind::Chart ||
+ eObjKind == PresObjKind::OrgChart ||
+ eObjKind == PresObjKind::Calc ||
+ eObjKind == PresObjKind::Graphic )
+ {
+ SfxItemSet aSet( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
+ aSet.Put( makeSdrTextContourFrameItem( true ) );
+ aSet.Put( SvxAdjustItem( SvxAdjust::Center, EE_PARA_JUST ) );
+
+ pSdrObj->SetMergedItemSet(aSet);
+ }
+
+ if( bUndo )
+ {
+ pUndoManager->AddUndoAction(getSdrModelFromSdrPage().GetSdrUndoFactory().CreateUndoNewObject(*pSdrObj));
+
+ pUndoManager->AddUndoAction( std::make_unique<UndoObjectPresentationKind>( *pSdrObj ) );
+ pUndoManager->AddUndoAction( std::make_unique<UndoObjectUserCall>(*pSdrObj) );
+ }
+
+ InsertPresObj(pSdrObj, eObjKind);
+ pSdrObj->SetUserCall(this);
+
+ pSdrObj->RecalcBoundRect();
+ }
+
+ return pSdrObj;
+}
+
+/*************************************************************************
+|*
+|* Creates presentation objects on the master page.
+|* All presentation objects get a UserCall to the page.
+|*
+\************************************************************************/
+
+SfxStyleSheet* SdPage::GetStyleSheetForMasterPageBackground() const
+{
+ OUString aName(GetLayoutName());
+ OUString aSep( SD_LT_SEPARATOR );
+ sal_Int32 nPos = aName.indexOf(aSep);
+
+ if (nPos != -1)
+ {
+ nPos = nPos + aSep.getLength();
+ aName = aName.copy(0, nPos);
+ }
+
+ aName += STR_LAYOUT_BACKGROUND;
+
+ SfxStyleSheetBasePool* pStShPool = getSdrModelFromSdrPage().GetStyleSheetPool();
+ SfxStyleSheetBase* pResult = pStShPool->Find(aName, SfxStyleFamily::Page);
+ return static_cast<SfxStyleSheet*>(pResult);
+}
+
+SfxStyleSheet* SdPage::GetStyleSheetForPresObj(PresObjKind eObjKind) const
+{
+ OUString aName(GetLayoutName());
+ OUString aSep( SD_LT_SEPARATOR );
+ sal_Int32 nPos = aName.indexOf(aSep);
+ if (nPos != -1)
+ {
+ nPos = nPos + aSep.getLength();
+ aName = aName.copy(0, nPos);
+ }
+
+ switch (eObjKind)
+ {
+ case PresObjKind::Outline:
+ {
+ aName = GetLayoutName() + " " + OUString::number( 1 );
+ }
+ break;
+
+ case PresObjKind::Title:
+ aName += STR_LAYOUT_TITLE;
+ break;
+
+ case PresObjKind::Notes:
+ aName += STR_LAYOUT_NOTES;
+ break;
+
+ case PresObjKind::Text:
+ aName += STR_LAYOUT_SUBTITLE;
+ break;
+
+ case PresObjKind::Header:
+ case PresObjKind::Footer:
+ case PresObjKind::DateTime:
+ case PresObjKind::SlideNumber:
+ aName += STR_LAYOUT_BACKGROUNDOBJECTS;
+ break;
+
+ default:
+ break;
+ }
+
+ SfxStyleSheetBasePool* pStShPool = getSdrModelFromSdrPage().GetStyleSheetPool();
+ SfxStyleSheetBase* pResult = pStShPool->Find(aName, SfxStyleFamily::Page);
+ return static_cast<SfxStyleSheet*>(pResult);
+}
+
+/** returns the presentation style with the given helpid from this masterpage or this
+ slides masterpage */
+SdStyleSheet* SdPage::getPresentationStyle( sal_uInt32 nHelpId ) const
+{
+ OUString aStyleName( GetLayoutName() );
+ const OUString aSep( SD_LT_SEPARATOR );
+ sal_Int32 nIndex = aStyleName.indexOf(aSep);
+ if( nIndex != -1 )
+ aStyleName = aStyleName.copy(0, nIndex + aSep.getLength());
+
+ OUString pNameId;
+ bool bOutline = false;
+ switch( nHelpId )
+ {
+ case HID_PSEUDOSHEET_TITLE: pNameId = STR_LAYOUT_TITLE; break;
+ case HID_PSEUDOSHEET_SUBTITLE: pNameId = STR_LAYOUT_SUBTITLE; break;
+ case HID_PSEUDOSHEET_OUTLINE1:
+ case HID_PSEUDOSHEET_OUTLINE2:
+ case HID_PSEUDOSHEET_OUTLINE3:
+ case HID_PSEUDOSHEET_OUTLINE4:
+ case HID_PSEUDOSHEET_OUTLINE5:
+ case HID_PSEUDOSHEET_OUTLINE6:
+ case HID_PSEUDOSHEET_OUTLINE7:
+ case HID_PSEUDOSHEET_OUTLINE8:
+ case HID_PSEUDOSHEET_OUTLINE9: pNameId = STR_LAYOUT_OUTLINE; bOutline = true; break;
+ case HID_PSEUDOSHEET_BACKGROUNDOBJECTS: pNameId = STR_LAYOUT_BACKGROUNDOBJECTS; break;
+ case HID_PSEUDOSHEET_BACKGROUND: pNameId = STR_LAYOUT_BACKGROUND; break;
+ case HID_PSEUDOSHEET_NOTES: pNameId = STR_LAYOUT_NOTES; break;
+
+ default:
+ OSL_FAIL( "SdPage::getPresentationStyle(), illegal argument!" );
+ return nullptr;
+ }
+ aStyleName += pNameId;
+ if (bOutline)
+ {
+ aStyleName += " " +
+ OUString::number( sal_Int32( nHelpId - HID_PSEUDOSHEET_OUTLINE ));
+ }
+
+ SfxStyleSheetBasePool* pStShPool = getSdrModelFromSdrPage().GetStyleSheetPool();
+ SfxStyleSheetBase* pResult = pStShPool->Find(aStyleName, SfxStyleFamily::Page);
+ return dynamic_cast<SdStyleSheet*>(pResult);
+}
+
+/*************************************************************************
+|*
+|* The presentation object rObj has changed and is no longer referenced by the
+|* presentation object of the master page.
+|* The UserCall is deleted.
+|*
+\************************************************************************/
+
+void SdPage::Changed(const SdrObject& rObj, SdrUserCallType eType, const ::tools::Rectangle& )
+{
+ if (maLockAutoLayoutArrangement.isLocked())
+ return;
+
+ switch (eType)
+ {
+ case SdrUserCallType::MoveOnly:
+ case SdrUserCallType::Resize:
+ {
+ if ( getSdrModelFromSdrPage().isLocked())
+ break;
+
+ if (!mbMaster)
+ {
+ if (rObj.GetUserCall())
+ {
+ SdrObject& _rObj = const_cast<SdrObject&>(rObj);
+ SfxUndoManager* pUndoManager
+ = static_cast<SdDrawDocument&>(getSdrModelFromSdrPage())
+ .GetUndoManager();
+ const bool bUndo
+ = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
+
+ if (bUndo)
+ pUndoManager->AddUndoAction(
+ std::make_unique<UndoObjectUserCall>(_rObj));
+
+ // Object was resized by user and does not listen to its slide anymore
+ _rObj.SetUserCall(nullptr);
+ }
+ }
+ else
+ {
+ // Object of the master page changed, therefore adjust
+ // object on all pages
+ sal_uInt16 nPageCount = static_cast<SdDrawDocument&>(getSdrModelFromSdrPage())
+ .GetSdPageCount(mePageKind);
+
+ for (sal_uInt16 i = 0; i < nPageCount; i++)
+ {
+ SdPage* pLoopPage = static_cast<SdDrawDocument&>(getSdrModelFromSdrPage())
+ .GetSdPage(i, mePageKind);
+
+ if (pLoopPage && this == &(pLoopPage->TRG_GetMasterPage()))
+ {
+ // Page listens to this master page, therefore
+ // adjust AutoLayout
+ pLoopPage->SetAutoLayout(pLoopPage->GetAutoLayout());
+ }
+ }
+ }
+ }
+ break;
+
+ case SdrUserCallType::Delete:
+ case SdrUserCallType::Removed:
+ default:
+ break;
+ }
+}
+
+/*************************************************************************
+|*
+|* Creates on a master page: background, title- and layout area
+|*
+\************************************************************************/
+
+void SdPage::CreateTitleAndLayout(bool bInit, bool bCreate )
+{
+ SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager());
+ const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
+
+ SdPage* pMasterPage = this;
+
+ if (!mbMaster)
+ {
+ pMasterPage = static_cast<SdPage*>(&(TRG_GetMasterPage()));
+ }
+
+ if (!pMasterPage)
+ {
+ return;
+ }
+
+ /**************************************************************************
+ * create background, title- and layout area
+ **************************************************************************/
+ if( mePageKind == PageKind::Standard )
+ {
+ pMasterPage->EnsureMasterPageDefaultBackground();
+ }
+
+ if (static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetDocumentType() != DocumentType::Impress)
+ return;
+
+ if( mePageKind == PageKind::Handout && bInit )
+ {
+ // handout template
+
+ // delete all available handout presentation objects
+ SdrObject *pObj=nullptr;
+ while( (pObj = pMasterPage->GetPresObj(PresObjKind::Handout)) != nullptr )
+ {
+ pMasterPage->RemoveObject(pObj->GetOrdNum());
+
+ if( bUndo )
+ {
+ pUndoManager->AddUndoAction(getSdrModelFromSdrPage().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
+ }
+ else
+ {
+ SdrObject::Free( pObj );
+ }
+ }
+
+ std::vector< ::tools::Rectangle > aAreas;
+ CalculateHandoutAreas( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()), pMasterPage->GetAutoLayout(), false, aAreas );
+
+ const bool bSkip = pMasterPage->GetAutoLayout() == AUTOLAYOUT_HANDOUT3;
+ std::vector< ::tools::Rectangle >::iterator iter( aAreas.begin() );
+
+ while( iter != aAreas.end() )
+ {
+ SdrPageObj* pPageObj = static_cast<SdrPageObj*>(pMasterPage->CreatePresObj(PresObjKind::Handout, false, (*iter++)) );
+ // #i105146# We want no content to be displayed for PageKind::Handout,
+ // so just never set a page as content
+ pPageObj->SetReferencedPage(nullptr);
+
+ if( bSkip && iter != aAreas.end() )
+ ++iter;
+ }
+ }
+
+ if( mePageKind != PageKind::Handout )
+ {
+ SdrObject* pMasterTitle = pMasterPage->GetPresObj( PresObjKind::Title );
+ if( pMasterTitle == nullptr )
+ pMasterPage->CreateDefaultPresObj(PresObjKind::Title);
+
+ SdrObject* pMasterOutline = pMasterPage->GetPresObj( mePageKind==PageKind::Notes ? PresObjKind::Notes : PresObjKind::Outline );
+ if( pMasterOutline == nullptr )
+ pMasterPage->CreateDefaultPresObj( mePageKind == PageKind::Standard ? PresObjKind::Outline : PresObjKind::Notes );
+ }
+
+ // create header&footer objects
+
+ if( !bCreate )
+ return;
+
+ if( mePageKind != PageKind::Standard )
+ {
+ SdrObject* pHeader = pMasterPage->GetPresObj( PresObjKind::Header );
+ if( pHeader == nullptr )
+ pMasterPage->CreateDefaultPresObj( PresObjKind::Header );
+ }
+
+ SdrObject* pDate = pMasterPage->GetPresObj( PresObjKind::DateTime );
+ if( pDate == nullptr )
+ pMasterPage->CreateDefaultPresObj( PresObjKind::DateTime );
+
+ SdrObject* pFooter = pMasterPage->GetPresObj( PresObjKind::Footer );
+ if( pFooter == nullptr )
+ pMasterPage->CreateDefaultPresObj( PresObjKind::Footer );
+
+ SdrObject* pNumber = pMasterPage->GetPresObj( PresObjKind::SlideNumber );
+ if( pNumber == nullptr )
+ pMasterPage->CreateDefaultPresObj( PresObjKind::SlideNumber );
+}
+
+namespace {
+
+const o3tl::enumarray<PageKind, char const *> PageKindVector = {
+ "PageKind::Standard", "PageKind::Notes", "PageKind::Handout"
+};
+
+const o3tl::enumarray<PresObjKind, const char*> PresObjKindVector = {
+ "PRESOBJ_NONE", "PRESOBJ_TITLE", "PRESOBJ_OUTLINE",
+ "PRESOBJ_TEXT" ,"PRESOBJ_GRAPHIC" , "PRESOBJ_OBJECT",
+ "PRESOBJ_CHART", "PRESOBJ_ORGCHART", "PRESOBJ_TABLE",
+ "PRESOBJ_PAGE", "PRESOBJ_HANDOUT",
+ "PRESOBJ_NOTES","PRESOBJ_HEADER", "PRESOBJ_FOOTER",
+ "PRESOBJ_DATETIME", "PRESOBJ_SLIDENUMBER", "PRESOBJ_CALC",
+ "PRESOBJ_MEDIA"
+};
+
+void getPresObjProp( const SdPage& rPage, const char* sObjKind, const char* sPageKind, double presObjPropValue[] )
+{
+ bool bNoObjectFound = true; //used to break from outer loop
+
+ const std::vector< Reference<XNode> >& objectInfo = static_cast< const SdDrawDocument& >(rPage.getSdrModelFromSdrPage()).GetObjectVector();
+ for( const Reference<XNode>& objectNode : objectInfo )
+ {
+ if(bNoObjectFound)
+ {
+ Reference<XNamedNodeMap> objectattrlist = objectNode->getAttributes();
+ Reference<XNode> objectattr = objectattrlist->getNamedItem("type");
+ OUString sObjType = objectattr->getNodeValue();
+
+ if (sObjType.equalsAscii(sObjKind))
+ {
+ Reference<XNodeList> objectChildren = objectNode->getChildNodes();
+ const int objSize = objectChildren->getLength();
+
+ for( int j=0; j< objSize; j++)
+ {
+ Reference<XNode> obj = objectChildren->item(j);
+ OUString nodename = obj->getNodeName();
+
+ //check whether child is blank 'text-node' or 'object-prop' node
+ if(nodename == "object-prop")
+ {
+ Reference<XNamedNodeMap> ObjAttributes = obj->getAttributes();
+ Reference<XNode> ObjPageKind = ObjAttributes->getNamedItem("pagekind");
+ OUString sObjPageKind = ObjPageKind->getNodeValue();
+
+ if (sObjPageKind.equalsAscii(sPageKind))
+ {
+ Reference<XNode> ObjSizeHeight = ObjAttributes->getNamedItem("relative-height");
+ OUString sValue = ObjSizeHeight->getNodeValue();
+ presObjPropValue[0] = sValue.toDouble();
+
+ Reference<XNode> ObjSizeWidth = ObjAttributes->getNamedItem("relative-width");
+ sValue = ObjSizeWidth->getNodeValue();
+ presObjPropValue[1] = sValue.toDouble();
+
+ Reference<XNode> ObjPosX = ObjAttributes->getNamedItem("relative-posX");
+ sValue = ObjPosX->getNodeValue();
+ presObjPropValue[2] = sValue.toDouble();
+
+ Reference<XNode> ObjPosY = ObjAttributes->getNamedItem("relative-posY");
+ sValue = ObjPosY->getNodeValue();
+ presObjPropValue[3] = sValue.toDouble();
+
+ bNoObjectFound = false;
+ break;
+ }
+ }
+ }
+ }
+ }
+ else
+ break;
+ }
+}
+
+}
+
+SdrObject* SdPage::CreateDefaultPresObj(PresObjKind eObjKind)
+{
+ if( eObjKind == PresObjKind::Title )
+ {
+ ::tools::Rectangle aTitleRect( GetTitleRect() );
+ return CreatePresObj(PresObjKind::Title, false, aTitleRect);
+ }
+ else if( eObjKind == PresObjKind::Outline )
+ {
+ ::tools::Rectangle aLayoutRect( GetLayoutRect() );
+ return CreatePresObj( PresObjKind::Outline, false, aLayoutRect);
+ }
+ else if( eObjKind == PresObjKind::Notes )
+ {
+ ::tools::Rectangle aLayoutRect( GetLayoutRect() );
+ return CreatePresObj( PresObjKind::Notes, false, aLayoutRect);
+ }
+ else if( (eObjKind == PresObjKind::Footer) || (eObjKind == PresObjKind::DateTime) || (eObjKind == PresObjKind::SlideNumber) || (eObjKind == PresObjKind::Header ) )
+ {
+ double propvalue[] = {0,0,0,0};
+ const char* sObjKind = PresObjKindVector[eObjKind];
+ const char* sPageKind = PageKindVector[mePageKind];
+ // create footer objects for standard master page
+ if( mePageKind == PageKind::Standard )
+ {
+ const ::tools::Long nLftBorder = GetLeftBorder();
+ const ::tools::Long nUppBorder = GetUpperBorder();
+
+ Point aPos ( nLftBorder, nUppBorder );
+ Size aSize ( GetSize() );
+
+ aSize.AdjustWidth( -(nLftBorder + GetRightBorder()) );
+ aSize.AdjustHeight( -(nUppBorder + GetLowerBorder()) );
+
+ getPresObjProp( *this, sObjKind, sPageKind, propvalue);
+ aPos.AdjustX(::tools::Long( aSize.Width() * propvalue[2] ) );
+ aPos.AdjustY(::tools::Long( aSize.Height() * propvalue[3] ) );
+ aSize.setWidth( ::tools::Long( aSize.Width() * propvalue[1] ) );
+ aSize.setHeight( ::tools::Long( aSize.Height() * propvalue[0] ) );
+
+ if(eObjKind == PresObjKind::Header )
+ {
+ OSL_FAIL( "SdPage::CreateDefaultPresObj() - can't create a header placeholder for a master slide" );
+ return nullptr;
+ }
+ else
+ {
+ ::tools::Rectangle aRect( aPos, aSize );
+ return CreatePresObj( eObjKind, false, aRect );
+ }
+ }
+ else
+ {
+ // create header&footer objects for handout and notes master
+ Size aPageSize ( GetSize() );
+ aPageSize.AdjustWidth( -(GetLeftBorder() + GetRightBorder()) );
+ aPageSize.AdjustHeight( -(GetUpperBorder() + GetLowerBorder()) );
+
+ Point aPosition ( GetLeftBorder(), GetUpperBorder() );
+
+ getPresObjProp( *this, sObjKind, sPageKind, propvalue);
+ int NOTES_HEADER_FOOTER_WIDTH = ::tools::Long(aPageSize.Width() * propvalue[1]);
+ int NOTES_HEADER_FOOTER_HEIGHT = ::tools::Long(aPageSize.Height() * propvalue[0]);
+ Size aSize( NOTES_HEADER_FOOTER_WIDTH, NOTES_HEADER_FOOTER_HEIGHT );
+ Point aPos ( 0 ,0 );
+ if( propvalue[2] == 0 )
+ aPos.setX( aPosition.X() );
+ else
+ aPos.setX( aPosition.X() + ::tools::Long( aPageSize.Width() - NOTES_HEADER_FOOTER_WIDTH ) );
+ if( propvalue[3] == 0 )
+ aPos.setY( aPosition.Y() );
+ else
+ aPos.setY( aPosition.Y() + ::tools::Long( aPageSize.Height() - NOTES_HEADER_FOOTER_HEIGHT ) );
+
+ ::tools::Rectangle aRect( aPos, aSize );
+ return CreatePresObj( eObjKind, false, aRect );
+ }
+ }
+ else
+ {
+ OSL_FAIL("SdPage::CreateDefaultPresObj() - unknown PRESOBJ kind" );
+ return nullptr;
+ }
+}
+
+void SdPage::DestroyDefaultPresObj(PresObjKind eObjKind)
+{
+ SdrObject* pObject = GetPresObj( eObjKind );
+
+ if( pObject )
+ {
+ SdDrawDocument* pDoc(static_cast< SdDrawDocument* >(&getSdrModelFromSdrPage()));
+ const bool bUndo = pDoc->IsUndoEnabled();
+ if( bUndo )
+ pDoc->AddUndo(pDoc->GetSdrUndoFactory().CreateUndoDeleteObject(*pObject));
+ SdrObjList* pOL = pObject->getParentSdrObjListFromSdrObject();
+ pOL->RemoveObject(pObject->GetOrdNumDirect());
+
+ if( !bUndo )
+ SdrObject::Free(pObject);
+ }
+}
+
+/*************************************************************************
+|*
+|* return title area
+|*
+\************************************************************************/
+
+::tools::Rectangle SdPage::GetTitleRect() const
+{
+ ::tools::Rectangle aTitleRect;
+
+ if (mePageKind != PageKind::Handout)
+ {
+ double propvalue[] = {0,0,0,0};
+
+ /******************************************************************
+ * standard- or note page: title area
+ ******************************************************************/
+ Point aTitlePos ( GetLeftBorder(), GetUpperBorder() );
+ Size aTitleSize ( GetSize() );
+ aTitleSize.AdjustWidth( -(GetLeftBorder() + GetRightBorder()) );
+ aTitleSize.AdjustHeight( -(GetUpperBorder() + GetLowerBorder()) );
+ const char* sPageKind = PageKindVector[mePageKind];
+
+ if (mePageKind == PageKind::Standard)
+ {
+ getPresObjProp( *this , "PRESOBJ_TITLE" ,sPageKind, propvalue);
+ aTitlePos.AdjustX(::tools::Long( aTitleSize.Width() * propvalue[2] ) );
+ aTitlePos.AdjustY(::tools::Long( aTitleSize.Height() * propvalue[3] ) );
+ aTitleSize.setWidth( ::tools::Long( aTitleSize.Width() * propvalue[1] ) );
+ aTitleSize.setHeight( ::tools::Long( aTitleSize.Height() * propvalue[0] ) );
+ }
+ else if (mePageKind == PageKind::Notes)
+ {
+ Point aPos = aTitlePos;
+ getPresObjProp( *this, "PRESOBJ_TITLE" ,sPageKind, propvalue);
+ aPos.AdjustX(::tools::Long( aTitleSize.Width() * propvalue[2] ) );
+ aPos.AdjustY(::tools::Long( aTitleSize.Height() * propvalue[3] ) );
+
+ // limit height
+ aTitleSize.setHeight( ::tools::Long( aTitleSize.Height() * propvalue[0] ) );
+ aTitleSize.setWidth( ::tools::Long( aTitleSize.Width() * propvalue[1] ) );
+
+ Size aPartArea = aTitleSize;
+ Size aSize;
+ sal_uInt16 nDestPageNum(GetPageNum());
+ SdrPage* pRefPage = nullptr;
+
+ if(nDestPageNum)
+ {
+ // only decrement if != 0, else we get 0xffff
+ nDestPageNum -= 1;
+ }
+
+ if(nDestPageNum < getSdrModelFromSdrPage().GetPageCount())
+ {
+ pRefPage = getSdrModelFromSdrPage().GetPage(nDestPageNum);
+ }
+
+ if ( pRefPage )
+ {
+ // scale actually page size into handout rectangle
+ double fH = pRefPage->GetWidth() == 0
+ ? 0 : static_cast<double>(aPartArea.Width()) / pRefPage->GetWidth();
+ double fV = pRefPage->GetHeight() == 0
+ ? 0 : static_cast<double>(aPartArea.Height()) / pRefPage->GetHeight();
+
+ if ( fH > fV )
+ fH = fV;
+ aSize.setWidth( static_cast<::tools::Long>(fH * pRefPage->GetWidth()) );
+ aSize.setHeight( static_cast<::tools::Long>(fH * pRefPage->GetHeight()) );
+
+ aPos.AdjustX((aPartArea.Width() - aSize.Width()) / 2 );
+ aPos.AdjustY((aPartArea.Height()- aSize.Height())/ 2 );
+ }
+
+ aTitlePos = aPos;
+ aTitleSize = aSize;
+ }
+
+ aTitleRect.SetPos(aTitlePos);
+ aTitleRect.SetSize(aTitleSize);
+ }
+
+ return aTitleRect;
+}
+
+/*************************************************************************
+|*
+|* return outline area
+|*
+\************************************************************************/
+
+::tools::Rectangle SdPage::GetLayoutRect() const
+{
+ ::tools::Rectangle aLayoutRect;
+
+ if (mePageKind != PageKind::Handout)
+ {
+ double propvalue[] = {0,0,0,0};
+
+ Point aLayoutPos ( GetLeftBorder(), GetUpperBorder() );
+ Size aLayoutSize ( GetSize() );
+ aLayoutSize.AdjustWidth( -(GetLeftBorder() + GetRightBorder()) );
+ aLayoutSize.AdjustHeight( -(GetUpperBorder() + GetLowerBorder()) );
+ const char* sPageKind = PageKindVector[mePageKind];
+
+ if (mePageKind == PageKind::Standard)
+ {
+ getPresObjProp( *this ,"PRESOBJ_OUTLINE", sPageKind, propvalue);
+ aLayoutPos.AdjustX(::tools::Long( aLayoutSize.Width() * propvalue[2] ) );
+ aLayoutPos.AdjustY(::tools::Long( aLayoutSize.Height() * propvalue[3] ) );
+ aLayoutSize.setWidth( ::tools::Long( aLayoutSize.Width() * propvalue[1] ) );
+ aLayoutSize.setHeight( ::tools::Long( aLayoutSize.Height() * propvalue[0] ) );
+ aLayoutRect.SetPos(aLayoutPos);
+ aLayoutRect.SetSize(aLayoutSize);
+ }
+ else if (mePageKind == PageKind::Notes)
+ {
+ getPresObjProp( *this, "PRESOBJ_NOTES", sPageKind, propvalue);
+ aLayoutPos.AdjustX(::tools::Long( aLayoutSize.Width() * propvalue[2] ) );
+ aLayoutPos.AdjustY(::tools::Long( aLayoutSize.Height() * propvalue[3] ) );
+ aLayoutSize.setWidth( ::tools::Long( aLayoutSize.Width() * propvalue[1] ) );
+ aLayoutSize.setHeight( ::tools::Long( aLayoutSize.Height() * propvalue[0] ) );
+ aLayoutRect.SetPos(aLayoutPos);
+ aLayoutRect.SetSize(aLayoutSize);
+ }
+ }
+
+ return aLayoutRect;
+}
+
+/**************************************************************************
+|*
+|* assign an AutoLayout
+|*
+\*************************************************************************/
+
+const int MAX_PRESOBJS = 7; // maximum number of presentation objects per layout
+const int VERTICAL = 0x8000;
+
+static constexpr PresObjKind operator|(PresObjKind e, int x)
+{
+ return static_cast<PresObjKind>(static_cast<int>(e) | x);
+}
+
+namespace {
+
+struct LayoutDescriptor
+{
+ PresObjKind meKind[MAX_PRESOBJS];
+ bool mbVertical[MAX_PRESOBJS];
+
+ LayoutDescriptor( PresObjKind k0 = PresObjKind::NONE, PresObjKind k1 = PresObjKind::NONE, PresObjKind k2 = PresObjKind::NONE, PresObjKind k3 = PresObjKind::NONE, PresObjKind k4 = PresObjKind::NONE, PresObjKind k5 = PresObjKind::NONE, PresObjKind k6 = PresObjKind::NONE );
+};
+
+}
+
+LayoutDescriptor::LayoutDescriptor( PresObjKind k0, PresObjKind k1, PresObjKind k2, PresObjKind k3, PresObjKind k4, PresObjKind k5, PresObjKind k6 )
+{
+ auto removeVertical = [] (PresObjKind k) { return static_cast<PresObjKind>(static_cast<int>(k) & ~VERTICAL); };
+ auto isVertical = [] (PresObjKind k) { return bool(static_cast<int>(k) & VERTICAL); };
+ meKind[0] = removeVertical(k0); mbVertical[0] = isVertical(k0);
+ meKind[1] = removeVertical(k1); mbVertical[1] = isVertical(k1);
+ meKind[2] = removeVertical(k2); mbVertical[2] = isVertical(k2);
+ meKind[3] = removeVertical(k3); mbVertical[3] = isVertical(k3);
+ meKind[4] = removeVertical(k4); mbVertical[4] = isVertical(k4);
+ meKind[5] = removeVertical(k5); mbVertical[5] = isVertical(k5);
+ meKind[6] = removeVertical(k6); mbVertical[6] = isVertical(k6);
+}
+
+static const LayoutDescriptor& GetLayoutDescriptor( AutoLayout eLayout )
+{
+ static const LayoutDescriptor aLayouts[AUTOLAYOUT_END-AUTOLAYOUT_START] =
+ {
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Text ), // AUTOLAYOUT_TITLE
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline ), // AUTOLAYOUT_CHART
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_2CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TEXTCHART
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline ), // AUTOLAYOUT_ORG
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TEXTCLbIP
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_CHARTTEXT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline ), // AUTOLAYOUT_TAB
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_CLIPTEXT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TEXTOBJ
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Object ), // AUTOLAYOUT_OBJ
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_CONTENT_2CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TEXTOBJ
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_CONTENT_OVER_CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_2CONTENT_CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TITLE_2CONTENT_OVER_CONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline ), // AUTOLAYOUT_TEXTOVEROBJ
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, // AUTOLAYOUT_TITLE_4CONTENT
+ PresObjKind::Outline, PresObjKind::Outline ),
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::NONE ), // AUTOLAYOUT_TITLE_ONLY
+ LayoutDescriptor( PresObjKind::NONE ), // AUTOLAYOUT_NONE
+ LayoutDescriptor( PresObjKind::Page, PresObjKind::Notes ), // AUTOLAYOUT_NOTES
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT1
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT2
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT3
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT4
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT6
+ LayoutDescriptor( PresObjKind::Title|VERTICAL, PresObjKind::Outline|VERTICAL, PresObjKind::Outline ),// AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT
+ LayoutDescriptor( PresObjKind::Title|VERTICAL, PresObjKind::Outline|VERTICAL ), // AUTOLAYOUT_VTITLE_VCONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline|VERTICAL ), // AUTOLAYOUT_TITLE_VCONTENT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline|VERTICAL, PresObjKind::Outline|VERTICAL ), // AUTOLAYOUT_TITLE_2VTEXT
+ LayoutDescriptor( ), // AUTOLAYOUT_HANDOUT9
+ LayoutDescriptor( PresObjKind::Text, PresObjKind::NONE ), // AUTOLAYOUT_ONLY_TEXT
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, // AUTOLAYOUT_4CLIPART
+ PresObjKind::Graphic, PresObjKind::Graphic ),
+ LayoutDescriptor( PresObjKind::Title, PresObjKind::Outline, PresObjKind::Outline, // AUTOLAYOUT_TITLE_6CONTENT
+ PresObjKind::Outline, PresObjKind::Outline, PresObjKind::Outline, PresObjKind::Outline )
+ };
+
+ if( (eLayout < AUTOLAYOUT_START) || (eLayout >= AUTOLAYOUT_END) )
+ eLayout = AUTOLAYOUT_NONE;
+
+ return aLayouts[ eLayout - AUTOLAYOUT_START ];
+}
+
+static OUString enumtoString(AutoLayout aut)
+{
+ OUString retstr;
+ switch (aut)
+ {
+ case AUTOLAYOUT_TITLE_CONTENT:
+ retstr="AUTOLAYOUT_TITLE_CONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_CONTENT_OVER_CONTENT:
+ retstr="AUTOLAYOUT_TITLE_CONTENT_OVER_CONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_CONTENT_2CONTENT:
+ retstr="AUTOLAYOUT_TITLE_CONTENT_2CONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_4CONTENT:
+ retstr="AUTOLAYOUT_TITLE_4CONTENT";
+ break;
+ case AUTOLAYOUT_ONLY_TEXT:
+ retstr="AUTOLAYOUT_ONLY_TEXT";
+ break;
+ case AUTOLAYOUT_TITLE_ONLY:
+ retstr="AUTOLAYOUT_TITLE_ONLY";
+ break;
+ case AUTOLAYOUT_TITLE_6CONTENT:
+ retstr="AUTOLAYOUT_TITLE_6CONTENT";
+ break;
+ case AUTOLAYOUT_START:
+ retstr="AUTOLAYOUT_START";
+ break;
+ case AUTOLAYOUT_TITLE_2CONTENT_CONTENT:
+ retstr="AUTOLAYOUT_TITLE_2CONTENT_CONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_2CONTENT_OVER_CONTENT:
+ retstr="AUTOLAYOUT_TITLE_2CONTENT_OVER_CONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_2CONTENT:
+ retstr="AUTOLAYOUT_TITLE_2CONTENT";
+ break;
+ case AUTOLAYOUT_VTITLE_VCONTENT:
+ retstr="AUTOLAYOUT_VTITLE_VCONTENT";
+ break;
+ case AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT:
+ retstr="AUTOLAYOUT_VTITLE_VCONTENT_OVER_VCONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_VCONTENT:
+ retstr="AUTOLAYOUT_TITLE_VCONTENT";
+ break;
+ case AUTOLAYOUT_TITLE_2VTEXT:
+ retstr="AUTOLAYOUT_TITLE_2VTEXT";
+ break;
+ default:
+ retstr="unknown";
+ break;
+ // case AUTOLAYOUT_TITLE_4SCONTENT: return "AUTOLAYOUT_TITLE_4SCONTENT";
+ }
+ return retstr;
+}
+
+static void CalcAutoLayoutRectangles( SdPage const & rPage,::tools::Rectangle* rRectangle ,const OUString& sLayoutType )
+{
+ ::tools::Rectangle aTitleRect;
+ ::tools::Rectangle aLayoutRect;
+
+ if( rPage.GetPageKind() != PageKind::Handout )
+ {
+ SdPage& rMasterPage = static_cast<SdPage&>(rPage.TRG_GetMasterPage());
+ SdrObject* pMasterTitle = rMasterPage.GetPresObj( PresObjKind::Title );
+ SdrObject* pMasterSubTitle = rMasterPage.GetPresObj( PresObjKind::Text );
+ SdrObject* pMasterOutline = rMasterPage.GetPresObj( rPage.GetPageKind()==PageKind::Notes ? PresObjKind::Notes : PresObjKind::Outline );
+
+ if( pMasterTitle )
+ aTitleRect = pMasterTitle->GetLogicRect();
+
+ if (aTitleRect.IsEmpty() )
+ aTitleRect = rPage.GetTitleRect();
+ if( pMasterSubTitle )
+ aLayoutRect = pMasterSubTitle->GetLogicRect();
+ else if( pMasterOutline )
+ aLayoutRect = pMasterOutline->GetLogicRect();
+
+ if (aLayoutRect.IsEmpty() )
+ aLayoutRect = rPage.GetLayoutRect();
+ }
+
+ rRectangle[0] = aTitleRect;
+ for( int i = 1; i < MAX_PRESOBJS; i++ )
+ rRectangle[i] = aLayoutRect;
+
+ const Point aTitlePos( aTitleRect.TopLeft() );
+ const Size aLayoutSize( aLayoutRect.GetSize() );
+ const Point aLayoutPos( aLayoutRect.TopLeft() );
+ double propvalue[] = {0,0,0,0};
+
+ const std::vector< Reference<XNode> >& layoutInfo = static_cast< const SdDrawDocument& >(rPage.getSdrModelFromSdrPage()).GetLayoutVector();
+ auto aIter = std::find_if(layoutInfo.begin(), layoutInfo.end(),
+ [&sLayoutType](const Reference<XNode>& layoutNode) {
+ Reference<XNamedNodeMap> layoutAttrList = layoutNode->getAttributes();
+
+ // get the attribute value of layout (i.e it's type)
+ OUString sLayoutAttName = layoutAttrList->getNamedItem("type")->getNodeValue();
+ return sLayoutAttName == sLayoutType;
+ });
+ if (aIter == layoutInfo.end())
+ return;
+
+ int count=0;
+ Reference<XNode> layoutNode = *aIter;
+ Reference<XNodeList> layoutChildren = layoutNode->getChildNodes();
+ const int presobjsize = layoutChildren->getLength();
+ for( int j=0; j< presobjsize ; j++)
+ {
+ OUString nodename;
+ Reference<XNode> presobj = layoutChildren->item(j);
+ nodename=presobj->getNodeName();
+
+ //check whether child is blank 'text-node' or 'presobj' node
+ if(nodename == "presobj")
+ {
+ // TODO: rework sd to permit arbitrary number of presentation objects
+ assert(count < MAX_PRESOBJS);
+
+ Reference<XNamedNodeMap> presObjAttributes = presobj->getAttributes();
+
+ Reference<XNode> presObjSizeHeight = presObjAttributes->getNamedItem("relative-height");
+ OUString sValue = presObjSizeHeight->getNodeValue();
+ propvalue[0] = sValue.toDouble();
+
+ Reference<XNode> presObjSizeWidth = presObjAttributes->getNamedItem("relative-width");
+ sValue = presObjSizeWidth->getNodeValue();
+ propvalue[1] = sValue.toDouble();
+
+ Reference<XNode> presObjPosX = presObjAttributes->getNamedItem("relative-posX");
+ sValue = presObjPosX->getNodeValue();
+ propvalue[2] = sValue.toDouble();
+
+ Reference<XNode> presObjPosY = presObjAttributes->getNamedItem("relative-posY");
+ sValue = presObjPosY->getNodeValue();
+ propvalue[3] = sValue.toDouble();
+
+ if(count == 0)
+ {
+ Size aSize ( aTitleRect.GetSize() );
+ aSize.setHeight( basegfx::fround(aSize.Height() * propvalue[0]) );
+ aSize.setWidth( basegfx::fround(aSize.Width() * propvalue[1]) );
+ Point aPos( basegfx::fround(aTitlePos.X() +(aSize.Width() * propvalue[2])),
+ basegfx::fround(aTitlePos.Y() + (aSize.Height() * propvalue[3])) );
+ rRectangle[count] = ::tools::Rectangle(aPos, aSize);
+ count = count+1;
+ }
+ else
+ {
+ Size aSize( basegfx::fround(aLayoutSize.Width() * propvalue[1]),
+ basegfx::fround(aLayoutSize.Height() * propvalue[0]) );
+ Point aPos( basegfx::fround(aLayoutPos.X() +(aSize.Width() * propvalue[2])),
+ basegfx::fround(aLayoutPos.Y() + (aSize.Height() * propvalue[3])) );
+ rRectangle[count] = ::tools::Rectangle (aPos, aSize);
+ count = count+1;
+ }
+ }
+ }
+}
+
+static void findAutoLayoutShapesImpl( SdPage& rPage, const LayoutDescriptor& rDescriptor, std::array<SdrObject*, MAX_PRESOBJS>& rShapes, bool bInit, bool bSwitchLayout )
+{
+ // init list of indexes for each presentation shape kind
+ // this is used to find subsequent shapes with the same presentation shape kind
+ o3tl::enumarray<PresObjKind,int> PresObjIndex;
+ PresObjIndex.fill(1);
+
+ bool bMissing = false;
+
+ // for each entry in the layoutdescriptor, arrange a presentation shape
+ for (int i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PresObjKind::NONE); i++)
+ {
+ PresObjKind eKind = rDescriptor.meKind[i];
+ SdrObject* pObj = nullptr;
+ while( (pObj = rPage.GetPresObj( eKind, PresObjIndex[eKind], true )) != nullptr )
+ {
+ PresObjIndex[eKind]++; // on next search for eKind, find next shape with same eKind
+
+ if( !bSwitchLayout || !pObj->IsEmptyPresObj() )
+ {
+ rShapes[i] = pObj;
+ break;
+ }
+ }
+
+ if( !pObj )
+ bMissing = true;
+ }
+
+ if( !(bMissing && bInit) )
+ return;
+
+ // for each entry in the layoutdescriptor, look for an alternative shape
+ for (int i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PresObjKind::NONE); i++)
+ {
+ if( rShapes[i] )
+ continue;
+
+ PresObjKind eKind = rDescriptor.meKind[i];
+
+ SdrObject* pObj = nullptr;
+ bool bFound = false;
+
+ const size_t nShapeCount = rPage.GetObjCount();
+ for(size_t nShapeIndex = 0; nShapeIndex < nShapeCount && !bFound; ++nShapeIndex )
+ {
+ pObj = rPage.GetObj(nShapeIndex);
+
+ if( pObj->IsEmptyPresObj() )
+ continue;
+
+ if( pObj->GetObjInventor() != SdrInventor::Default )
+ continue;
+
+ // do not reuse shapes that are already part of the layout
+ if( std::find( rShapes.begin(), rShapes.end(), pObj ) != rShapes.end() )
+ continue;
+
+ bool bPresStyle = pObj->GetStyleSheet() && (pObj->GetStyleSheet()->GetFamily() == SfxStyleFamily::Page);
+ SdrObjKind eSdrObjKind = pObj->GetObjIdentifier();
+
+ switch( eKind )
+ {
+ case PresObjKind::Title:
+ bFound = eSdrObjKind == SdrObjKind::TitleText;
+ break;
+ case PresObjKind::Table:
+ bFound = eSdrObjKind == SdrObjKind::Table;
+ break;
+ case PresObjKind::Media:
+ bFound = eSdrObjKind == SdrObjKind::Media;
+ break;
+ case PresObjKind::Outline:
+ bFound = (eSdrObjKind == SdrObjKind::OutlineText) ||
+ ((eSdrObjKind == SdrObjKind::Text) && bPresStyle) ||
+ (eSdrObjKind == SdrObjKind::Table) || (eSdrObjKind == SdrObjKind::Media) || (eSdrObjKind == SdrObjKind::Graphic) || (eSdrObjKind == SdrObjKind::OLE2);
+ break;
+ case PresObjKind::Graphic:
+ bFound = eSdrObjKind == SdrObjKind::Graphic;
+ break;
+ case PresObjKind::Object:
+ if( eSdrObjKind == SdrObjKind::OLE2 )
+ {
+ SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj );
+ if( pOle2 )
+ {
+ if( pOle2->IsEmpty() )
+ bFound = true;
+ else
+ {
+ ::comphelper::IEmbeddedHelper* pPersist(rPage.getSdrModelFromSdrPage().GetPersist());
+
+ if( pPersist )
+ {
+ uno::Reference < embed::XEmbeddedObject > xObject = pPersist->getEmbeddedObjectContainer().
+ GetEmbeddedObject( pOle2->GetPersistName() );
+
+ // TODO CL->KA: Why is this not working anymore?
+ if( xObject.is() )
+ {
+ SvGlobalName aClassId( xObject->getClassID() );
+
+ const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID );
+ const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID );
+ const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID );
+
+ if( aPluginClassId != aClassId && aAppletClassId != aClassId && aIFrameClassId != aClassId )
+ {
+ bFound = true;
+ }
+ }
+ }
+ }
+ }
+ }
+ break;
+ case PresObjKind::Chart:
+ case PresObjKind::Calc:
+ if( eSdrObjKind == SdrObjKind::OLE2 )
+ {
+ SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj );
+ if( pOle2 )
+ {
+ if(
+ ((eKind == PresObjKind::Chart) &&
+ ( pOle2->GetProgName() == "StarChart" || pOle2->IsChart() ) )
+ ||
+ ((eKind == PresObjKind::Calc) &&
+ ( pOle2->GetProgName() == "StarCalc" || pOle2->IsCalc() ) ) )
+ {
+ bFound = true;
+ }
+ }
+ break;
+ }
+ else if( eSdrObjKind == SdrObjKind::Table )
+ {
+ bFound = true;
+ }
+ break;
+ case PresObjKind::Page:
+ case PresObjKind::Handout:
+ bFound = eSdrObjKind == SdrObjKind::Page;
+ break;
+ case PresObjKind::Notes:
+ case PresObjKind::Text:
+ bFound = (bPresStyle && (eSdrObjKind == SdrObjKind::Text)) || (eSdrObjKind == SdrObjKind::OutlineText);
+ break;
+ default:
+ break;
+ }
+ }
+
+ if( bFound )
+ rShapes[i] = pObj;
+ }
+}
+
+void SdPage::SetAutoLayout(AutoLayout eLayout, bool bInit, bool bCreate )
+{
+ sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement );
+
+ const bool bSwitchLayout = eLayout != GetAutoLayout();
+
+ SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager());
+ const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
+
+ meAutoLayout = eLayout;
+
+ // if needed, creates and initialises the presentation shapes on this slides master page
+ CreateTitleAndLayout(bInit, bCreate);
+
+ if((meAutoLayout == AUTOLAYOUT_NONE && maPresentationShapeList.isEmpty()) || mbMaster)
+ {
+ // MasterPage or no layout and no presentation shapes available, nothing to do
+ return;
+ }
+
+ ::tools::Rectangle aRectangle[MAX_PRESOBJS];
+ const LayoutDescriptor& aDescriptor = GetLayoutDescriptor( meAutoLayout );
+ OUString sLayoutName( enumtoString(meAutoLayout) );
+ CalcAutoLayoutRectangles( *this, aRectangle, sLayoutName);
+
+ o3tl::sorted_vector< SdrObject* > aUsedPresentationObjects;
+
+ std::array<SdrObject*, MAX_PRESOBJS > aLayoutShapes;
+ aLayoutShapes.fill(nullptr);
+ findAutoLayoutShapesImpl( *this, aDescriptor, aLayoutShapes, bInit, bSwitchLayout );
+
+ // for each entry in the layoutdescriptor, arrange a presentation shape
+ for (int i = 0; (i < MAX_PRESOBJS) && (aDescriptor.meKind[i] != PresObjKind::NONE); i++)
+ {
+ PresObjKind eKind = aDescriptor.meKind[i];
+ SdrObject* pObj = InsertAutoLayoutShape( aLayoutShapes[i], eKind, aDescriptor.mbVertical[i], aRectangle[i], bInit );
+ if( pObj )
+ aUsedPresentationObjects.insert(pObj); // remember that we used this empty shape
+ }
+
+ // now delete all empty presentation objects that are no longer used by the new layout
+ if( !bInit )
+ return;
+
+ SdrObject* pObj = nullptr;
+ maPresentationShapeList.seekShape(0);
+
+ while( (pObj = maPresentationShapeList.getNextShape()) )
+ {
+ if( aUsedPresentationObjects.count(pObj) == 0 )
+ {
+
+ if( pObj->IsEmptyPresObj() )
+ {
+ if( bUndo )
+ pUndoManager->AddUndoAction(getSdrModelFromSdrPage().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
+
+ RemoveObject( pObj->GetOrdNum() );
+
+ if( !bUndo )
+ SdrObject::Free( pObj );
+ }
+/* #i108541# keep non empty pres obj as pres obj even if they are not part of the current layout */
+ }
+ }
+}
+
+/*************************************************************************
+|*
+|* insert object
+|*
+\************************************************************************/
+
+void SdPage::NbcInsertObject(SdrObject* pObj, size_t nPos)
+{
+ FmFormPage::NbcInsertObject(pObj, nPos);
+
+ static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).InsertObject(pObj);
+
+ SdrLayerID nId = pObj->GetLayer();
+ if( mbMaster )
+ {
+ if( nId == SdrLayerID(0) )
+ pObj->NbcSetLayer( SdrLayerID(2) ); // wrong layer. corrected to BackgroundObj layer
+ }
+ else
+ {
+ if( nId == SdrLayerID(2) )
+ pObj->NbcSetLayer( SdrLayerID(0) ); // wrong layer. corrected to layout layer
+ }
+}
+
+/*************************************************************************
+|*
+|* remove object
+|*
+\************************************************************************/
+
+SdrObject* SdPage::RemoveObject(size_t nObjNum)
+{
+ onRemoveObject(GetObj( nObjNum ));
+ return FmFormPage::RemoveObject(nObjNum);
+}
+
+/*************************************************************************
+|*
+|* remove object without broadcast
+|*
+\************************************************************************/
+
+SdrObject* SdPage::NbcRemoveObject(size_t nObjNum)
+{
+ onRemoveObject(GetObj( nObjNum ));
+ return FmFormPage::NbcRemoveObject(nObjNum);
+}
+
+// Also override ReplaceObject methods to realize when
+// objects are removed with this mechanism instead of RemoveObject
+SdrObject* SdPage::ReplaceObject(SdrObject* pNewObj, size_t nObjNum)
+{
+ onRemoveObject(GetObj( nObjNum ));
+ return FmFormPage::ReplaceObject(pNewObj, nObjNum);
+}
+
+// called after a shape is removed or replaced from this slide
+
+void SdPage::onRemoveObject( SdrObject* pObject )
+{
+ if( pObject )
+ {
+ RemovePresObj(pObject);
+
+ static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).RemoveObject(pObject);
+
+ removeAnimations( pObject );
+ }
+}
+
+void SdPage::SetSize(const Size& aSize)
+{
+ Size aOldSize = GetSize();
+
+ if (aSize != aOldSize)
+ {
+ FmFormPage::SetSize(aSize);
+ }
+}
+
+void SdPage::SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 nLwr)
+{
+ if (nLft != GetLeftBorder() || nUpp != GetUpperBorder() ||
+ nRgt != GetRightBorder() || nLwr != GetLowerBorder() )
+ {
+ FmFormPage::SetBorder(nLft, nUpp, nRgt, nLwr);
+ }
+}
+
+void SdPage::SetLeftBorder(sal_Int32 nBorder)
+{
+ if (nBorder != GetLeftBorder() )
+ {
+ FmFormPage::SetLeftBorder(nBorder);
+ }
+}
+
+void SdPage::SetRightBorder(sal_Int32 nBorder)
+{
+ if (nBorder != GetRightBorder() )
+ {
+ FmFormPage::SetRightBorder(nBorder);
+ }
+}
+
+void SdPage::SetUpperBorder(sal_Int32 nBorder)
+{
+ if (nBorder != GetUpperBorder() )
+ {
+ FmFormPage::SetUpperBorder(nBorder);
+ }
+}
+
+void SdPage::SetLowerBorder(sal_Int32 nBorder)
+{
+ if (nBorder != GetLowerBorder() )
+ {
+ FmFormPage::SetLowerBorder(nBorder);
+ }
+}
+
+/*************************************************************************
+|*
+|* Adjust all objects to new page size.
+|*
+|* bScaleAllObj: all objects are scaled into the new area within the page
+|* margins. We scale the position and size. For presentation objects on the
+|* master page, we also scale the font height of the presentation template.
+|*
+\************************************************************************/
+
+void SdPage::ScaleObjects(const Size& rNewPageSize, const ::tools::Rectangle& rNewBorderRect, bool bScaleAllObj)
+{
+ sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement );
+
+ mbScaleObjects = bScaleAllObj;
+ SdrObject* pObj = nullptr;
+ Point aRefPnt(0, 0);
+ Size aNewPageSize(rNewPageSize);
+ sal_Int32 nLeft = rNewBorderRect.Left();
+ sal_Int32 nRight = rNewBorderRect.Right();
+ sal_Int32 nUpper = rNewBorderRect.Top();
+ sal_Int32 nLower = rNewBorderRect.Bottom();
+
+ // negative values are fixed values
+ // -> use up to date values
+ if (aNewPageSize.Width() < 0)
+ {
+ aNewPageSize.setWidth( GetWidth() );
+ }
+ if (aNewPageSize.Height() < 0)
+ {
+ aNewPageSize.setHeight( GetHeight() );
+ }
+ if (nLeft < 0)
+ {
+ nLeft = GetLeftBorder();
+ }
+ if (nRight < 0)
+ {
+ nRight = GetRightBorder();
+ }
+ if (nUpper < 0)
+ {
+ nUpper = GetUpperBorder();
+ }
+ if (nLower < 0)
+ {
+ nLower = GetLowerBorder();
+ }
+
+ Size aBackgroundSize(aNewPageSize);
+
+ if (mbScaleObjects)
+ {
+ aBackgroundSize.AdjustWidth( -(nLeft + nRight) );
+ aBackgroundSize.AdjustHeight( -(nUpper + nLower) );
+ aNewPageSize = aBackgroundSize;
+ }
+
+ ::tools::Long nOldWidth = GetWidth() - GetLeftBorder() - GetRightBorder();
+ ::tools::Long nOldHeight = GetHeight() - GetUpperBorder() - GetLowerBorder();
+
+ Fraction aFractX(aNewPageSize.Width(), nOldWidth);
+ Fraction aFractY(aNewPageSize.Height(), nOldHeight);
+
+ const size_t nObjCnt = (mbScaleObjects ? GetObjCount() : 0);
+
+ for (size_t nObj = 0; nObj < nObjCnt; ++nObj)
+ {
+ bool bIsPresObjOnMaster = false;
+
+ // all Objects
+ pObj = GetObj(nObj);
+
+ if (mbMaster && IsPresObj(pObj))
+ {
+ // There is a presentation object on the master page
+ bIsPresObjOnMaster = true;
+ }
+
+ if (pObj)
+ {
+ // remember aTopLeft as original TopLeft
+ Point aTopLeft(pObj->GetCurrentBoundRect().TopLeft());
+
+ if (!pObj->IsEdgeObj())
+ {
+ /**************************************************************
+ * Scale objects
+ **************************************************************/
+ if (mbScaleObjects)
+ {
+ // use aTopLeft as original TopLeft
+ aRefPnt = aTopLeft;
+ }
+
+ pObj->Resize(aRefPnt, aFractX, aFractY);
+
+ if (mbScaleObjects)
+ {
+ SdrObjKind eObjKind = pObj->GetObjIdentifier();
+
+ if (bIsPresObjOnMaster)
+ {
+ /**********************************************************
+ * presentation template: adjust test height
+ **********************************************************/
+
+ if (pObj == GetPresObj(PresObjKind::Title, 0))
+ {
+ SfxStyleSheet* pTitleSheet = GetStyleSheetForPresObj(PresObjKind::Title);
+
+ if (pTitleSheet)
+ {
+ SfxItemSet& rSet = pTitleSheet->GetItemSet();
+
+ const SvxFontHeightItem& rOldHgt = rSet.Get(EE_CHAR_FONTHEIGHT);
+ sal_uLong nFontHeight = rOldHgt.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT));
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) )
+ {
+ const SvxFontHeightItem& rOldHgt2 = rSet.Get(EE_CHAR_FONTHEIGHT_CJK);
+ nFontHeight = rOldHgt2.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK));
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) )
+ {
+ const SvxFontHeightItem& rOldHgt2 = rSet.Get(EE_CHAR_FONTHEIGHT_CTL);
+ nFontHeight = rOldHgt2.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL));
+ }
+
+ pTitleSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
+ }
+ }
+ else if (pObj == GetPresObj(PresObjKind::Outline, 0))
+ {
+ OUString aName(GetLayoutName() + " ");
+
+ for (sal_Int32 i=1; i<=9; i++)
+ {
+ OUString sLayoutName( aName + OUString::number( i ) );
+ SfxStyleSheet* pOutlineSheet = static_cast<SfxStyleSheet*>(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetStyleSheetPool()->Find(sLayoutName, SfxStyleFamily::Page));
+
+ if (pOutlineSheet)
+ {
+ // Calculate new font height
+ SfxItemSet aTempSet(pOutlineSheet->GetItemSet());
+
+ const SvxFontHeightItem& rOldHgt = aTempSet.Get(EE_CHAR_FONTHEIGHT);
+ sal_uLong nFontHeight = rOldHgt.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT));
+
+ if( SfxItemState::DEFAULT == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) )
+ {
+ const SvxFontHeightItem& rOldHgt2 = aTempSet.Get(EE_CHAR_FONTHEIGHT_CJK);
+ nFontHeight = rOldHgt2.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK));
+ }
+
+ if( SfxItemState::DEFAULT == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) )
+ {
+ const SvxFontHeightItem& rOldHgt2 = aTempSet.Get(EE_CHAR_FONTHEIGHT_CTL);
+ nFontHeight = rOldHgt2.GetHeight();
+ nFontHeight = ::tools::Long(nFontHeight * static_cast<double>(aFractY));
+ aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL));
+ }
+
+ // adjust bullet
+ static_cast<SdStyleSheet*>(pOutlineSheet)->AdjustToFontHeight(aTempSet, false);
+
+ // Special treatment: reset the INVALIDS to
+ // NULL pointer (otherwise we have INVALID's
+ // or pointer to the DefaultItems in the
+ // template; both would suppress the
+ // attribute inheritance)
+ aTempSet.ClearInvalidItems();
+
+ // Special treatment: only the valid parts
+ // of the BulletItems
+ if (aTempSet.GetItemState(EE_PARA_BULLET) == SfxItemState::DEFAULT)
+ {
+ SvxBulletItem aOldBulItem( pOutlineSheet->GetItemSet().Get(EE_PARA_BULLET) );
+ const SvxBulletItem& rNewBulItem = aTempSet.Get(EE_PARA_BULLET);
+ aOldBulItem.CopyValidProperties(rNewBulItem);
+ aTempSet.Put(aOldBulItem);
+ }
+
+ pOutlineSheet->GetItemSet().Put(aTempSet);
+ pOutlineSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
+ }
+ }
+ }
+ else if (pObj == GetPresObj(PresObjKind::Notes, 0))
+ {
+ SfxStyleSheet* pNotesSheet = GetStyleSheetForPresObj(PresObjKind::Notes);
+
+ if (pNotesSheet)
+ {
+ sal_uLong nHeight = pObj->GetLogicRect().GetSize().Height();
+ sal_uLong nFontHeight = static_cast<sal_uLong>(nHeight * 0.0741);
+ SfxItemSet& rSet = pNotesSheet->GetItemSet();
+ rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT ));
+ rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK ));
+ rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL ));
+ pNotesSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
+ }
+ }
+ }
+ else if ( eObjKind != SdrObjKind::TitleText &&
+ eObjKind != SdrObjKind::OutlineText &&
+ dynamic_cast< const SdrTextObj *>( pObj ) != nullptr &&
+ pObj->GetOutlinerParaObject() )
+ {
+ /******************************************************
+ * normal text object: adjust text height
+ ******************************************************/
+ SvtScriptType nScriptType = pObj->GetOutlinerParaObject()->GetTextObject().GetScriptType();
+ sal_uInt16 nWhich = EE_CHAR_FONTHEIGHT;
+ if ( nScriptType == SvtScriptType::ASIAN )
+ nWhich = EE_CHAR_FONTHEIGHT_CJK;
+ else if ( nScriptType == SvtScriptType::COMPLEX )
+ nWhich = EE_CHAR_FONTHEIGHT_CTL;
+
+ // use more modern method to scale the text height
+ sal_uInt32 nFontHeight = static_cast<const SvxFontHeightItem&>(pObj->GetMergedItem(nWhich)).GetHeight();
+ sal_uInt32 nNewFontHeight = sal_uInt32(static_cast<double>(nFontHeight) * static_cast<double>(aFractY));
+
+ pObj->SetMergedItem(SvxFontHeightItem(nNewFontHeight, 100, nWhich));
+ }
+ }
+ }
+
+ if (mbScaleObjects && !pObj->IsEdgeObj())
+ {
+ /**************************************************************
+ * scale object position
+ **************************************************************/
+ Point aNewPos;
+
+ // corrected scaling; only distances may be scaled
+ // use aTopLeft as original TopLeft
+ aNewPos.setX( ::tools::Long((aTopLeft.X() - GetLeftBorder()) * static_cast<double>(aFractX)) + nLeft );
+ aNewPos.setY( ::tools::Long((aTopLeft.Y() - GetUpperBorder()) * static_cast<double>(aFractY)) + nUpper );
+
+ Size aVec(aNewPos.X() - aTopLeft.X(), aNewPos.Y() - aTopLeft.Y());
+
+ if (aVec.Height() != 0 || aVec.Width() != 0)
+ {
+ pObj->NbcMove(aVec);
+ }
+
+ pObj->SetChanged();
+ pObj->BroadcastObjectChange();
+ }
+ }
+ }
+}
+
+static SdrObject* convertPresentationObjectImpl(SdPage& rPage, SdrObject* pSourceObj, PresObjKind& eObjKind, bool bVertical, const ::tools::Rectangle& rRect)
+{
+ SdDrawDocument& rModel(static_cast< SdDrawDocument& >(rPage.getSdrModelFromSdrPage()));
+ if( !pSourceObj )
+ return pSourceObj;
+
+ SfxUndoManager* pUndoManager = rModel.GetUndoManager();
+ const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && rPage.IsInserted();
+
+ SdrObject* pNewObj = pSourceObj;
+ if((eObjKind == PresObjKind::Outline) && (pSourceObj->GetObjIdentifier() == SdrObjKind::Text) )
+ {
+ pNewObj = rPage.CreatePresObj(PresObjKind::Outline, bVertical, rRect);
+
+ // Set text of the subtitle into PRESOBJ_OUTLINE
+ OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject();
+
+ if(pOutlParaObj)
+ {
+ // assign text
+ SdOutliner* pOutl = rModel.GetInternalOutliner();
+ pOutl->Clear();
+ pOutl->SetText( *pOutlParaObj );
+ pNewObj->SetOutlinerParaObject( pOutl->CreateParaObject() );
+ pOutlParaObj = pNewObj->GetOutlinerParaObject();
+ pOutl->Clear();
+ pNewObj->SetEmptyPresObj(false);
+
+ for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++)
+ {
+ // assign new template
+ OUString aName( rPage.GetLayoutName() + " " + OUString::number( nLevel ) );
+ SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>( rModel.GetStyleSheetPool()->Find(aName, SfxStyleFamily::Page) );
+
+ if (pSheet && nLevel == 1)
+ {
+ SfxStyleSheet* pSubtitleSheet = rPage.GetStyleSheetForPresObj(PresObjKind::Text);
+
+ if (pSubtitleSheet)
+ pOutlParaObj->ChangeStyleSheetName(SfxStyleFamily::Page, pSubtitleSheet->GetName(), pSheet->GetName());
+ }
+ }
+
+ // Remove LRSpace item
+ SfxItemSetFixed<EE_PARA_LRSPACE, EE_PARA_LRSPACE> aSet(rModel.GetPool());
+
+ aSet.Put(pNewObj->GetMergedItemSet());
+
+ aSet.ClearItem(EE_PARA_LRSPACE);
+
+ pNewObj->SetMergedItemSet(aSet);
+
+ if( bUndo )
+ pUndoManager->AddUndoAction( rModel.GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj) );
+
+ // Remove outline shape from page
+ rPage.RemoveObject( pSourceObj->GetOrdNum() );
+
+ if( !bUndo )
+ SdrObject::Free( pSourceObj );
+ }
+ }
+ else if((eObjKind == PresObjKind::Text) && (pSourceObj->GetObjIdentifier() == SdrObjKind::OutlineText) )
+ {
+ // is there an outline shape we can use to replace empty subtitle shape?
+ pNewObj = rPage.CreatePresObj(PresObjKind::Text, bVertical, rRect);
+
+ // Set text of the outline object into PRESOBJ_TITLE
+ OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject();
+
+ if(pOutlParaObj)
+ {
+ // assign text
+ SdOutliner* pOutl = rModel.GetInternalOutliner();
+ pOutl->Clear();
+ pOutl->SetText( *pOutlParaObj );
+ pNewObj->SetOutlinerParaObject( pOutl->CreateParaObject() );
+ pOutl->Clear();
+ pNewObj->SetEmptyPresObj(false);
+
+ // reset left indent
+ SfxItemSetFixed<EE_PARA_LRSPACE, EE_PARA_LRSPACE> aSet(rModel.GetPool());
+
+ aSet.Put(pNewObj->GetMergedItemSet());
+
+ const SvxLRSpaceItem& rLRItem = aSet.Get(EE_PARA_LRSPACE);
+ SvxLRSpaceItem aNewLRItem(rLRItem);
+ aNewLRItem.SetTextLeft(0);
+ aSet.Put(aNewLRItem);
+
+ pNewObj->SetMergedItemSet(aSet);
+
+ SfxStyleSheet* pSheet = rPage.GetStyleSheetForPresObj(PresObjKind::Text);
+ if (pSheet)
+ pNewObj->SetStyleSheet(pSheet, true);
+
+ // Remove subtitle shape from page
+ if( bUndo )
+ pUndoManager->AddUndoAction(rModel.GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj));
+
+ rPage.RemoveObject( pSourceObj->GetOrdNum() );
+
+ if( !bUndo )
+ SdrObject::Free( pSourceObj );
+ }
+ }
+ else if((eObjKind == PresObjKind::Outline) && (pSourceObj->GetObjIdentifier() != SdrObjKind::OutlineText) )
+ {
+ switch( pSourceObj->GetObjIdentifier() )
+ {
+ case SdrObjKind::Table: eObjKind = PresObjKind::Table; break;
+ case SdrObjKind::Media: eObjKind = PresObjKind::Media; break;
+ case SdrObjKind::Graphic: eObjKind = PresObjKind::Graphic; break;
+ case SdrObjKind::OLE2: eObjKind = PresObjKind::Object; break;
+ default: break;
+ }
+ }
+
+ return pNewObj;
+}
+
+/** reuses or creates a presentation shape for an auto layout that fits the given parameter
+
+ @param eObjKind
+ The kind of presentation shape we like to have
+ @param nIndex
+ If > 1 we skip the first nIndex-1 shapes with the presentation shape kind eObjKind while
+ looking for an existing presentation shape
+ @param bVertical
+ If true, the shape is created vertical if bInit is true
+ @param rRect
+ The rectangle that should be used to transform the shape
+ @param bInit
+ If true the shape is created if not found
+ @returns
+ A presentation shape that was either found or created with the given parameters
+*/
+SdrObject* SdPage::InsertAutoLayoutShape(SdrObject* pObj, PresObjKind eObjKind, bool bVertical, const ::tools::Rectangle& rRect, bool bInit)
+{
+ SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager());
+ const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
+
+ if (!pObj && bInit)
+ {
+ pObj = CreatePresObj(eObjKind, bVertical, rRect);
+ }
+ else if ( pObj && (pObj->GetUserCall() || bInit) )
+ {
+ // convert object if shape type does not match kind (f.e. converting outline text to subtitle text)
+ if( bInit )
+ pObj = convertPresentationObjectImpl(*this, pObj, eObjKind, bVertical, rRect);
+
+ if( bUndo )
+ {
+ pUndoManager->AddUndoAction( getSdrModelFromSdrPage().GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
+ pUndoManager->AddUndoAction( getSdrModelFromSdrPage().GetSdrUndoFactory().CreateUndoAttrObject( *pObj, true, true ) );
+ pUndoManager->AddUndoAction( std::make_unique<UndoObjectUserCall>( *pObj ) );
+ }
+
+ pObj->AdjustToMaxRect(rRect);
+
+ pObj->SetUserCall(this);
+
+ SdrTextObj* pTextObject = dynamic_cast< SdrTextObj* >(pObj);
+ if( pTextObject )
+ {
+ if( pTextObject->IsVerticalWriting() != bVertical )
+ {
+ pTextObject->SetVerticalWriting( bVertical );
+
+ // here make sure the correct anchoring is used when the object
+ // is re-used but orientation is changed
+ if(PresObjKind::Outline == eObjKind)
+ pTextObject->SetMergedItem(SdrTextHorzAdjustItem( bVertical ? SDRTEXTHORZADJUST_RIGHT : SDRTEXTHORZADJUST_BLOCK ));
+ }
+
+ if( !mbMaster && (pTextObject->GetObjIdentifier() != SdrObjKind::Table) )
+ {
+ if ( pTextObject->IsAutoGrowHeight() )
+ {
+ // switch off AutoGrowHeight, set new MinHeight
+ SfxItemSet aTempAttr( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
+ SdrMetricItem aMinHeight( makeSdrTextMinFrameHeightItem(rRect.GetSize().Height()) );
+ aTempAttr.Put( aMinHeight );
+ aTempAttr.Put( makeSdrTextAutoGrowHeightItem(false) );
+ pTextObject->SetMergedItemSet(aTempAttr);
+ pTextObject->SetLogicRect(rRect);
+
+ // switch on AutoGrowHeight
+ SfxItemSet aAttr( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
+ aAttr.Put( makeSdrTextAutoGrowHeightItem(true) );
+
+ pTextObject->SetMergedItemSet(aAttr);
+ }
+
+ if ( pTextObject->IsAutoGrowWidth() )
+ {
+ // switch off AutoGrowWidth , set new MinWidth
+ SfxItemSet aTempAttr( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
+ SdrMetricItem aMinWidth( makeSdrTextMinFrameWidthItem(rRect.GetSize().Width()) );
+ aTempAttr.Put( aMinWidth );
+ aTempAttr.Put( makeSdrTextAutoGrowWidthItem(false) );
+ pTextObject->SetMergedItemSet(aTempAttr);
+ pTextObject->SetLogicRect(rRect);
+
+ // switch on AutoGrowWidth
+ SfxItemSet aAttr( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
+ aAttr.Put( makeSdrTextAutoGrowWidthItem(true) );
+ pTextObject->SetMergedItemSet(aAttr);
+ }
+ }
+ }
+ }
+
+ if(pObj && bInit )
+ {
+ if( !IsPresObj( pObj ) )
+ {
+ if( bUndo )
+ pUndoManager->AddUndoAction( std::make_unique<UndoObjectPresentationKind>( *pObj ) );
+
+ InsertPresObj( pObj, eObjKind );
+ }
+
+ // make adjustments for vertical title and outline shapes
+ if( bVertical && (( eObjKind == PresObjKind::Title) || (eObjKind == PresObjKind::Outline)))
+ {
+ SfxItemSet aNewSet(pObj->GetMergedItemSet());
+ aNewSet.Put( makeSdrTextAutoGrowWidthItem(true) );
+ aNewSet.Put( makeSdrTextAutoGrowHeightItem(false) );
+ if( eObjKind == PresObjKind::Outline )
+ {
+ aNewSet.Put( SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP) );
+ aNewSet.Put( SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT) );
+ }
+ pObj->SetMergedItemSet(aNewSet);
+ }
+ }
+
+ if ( pObj && (pObj->GetUserCall() || bInit) && ( pObj->IsEmptyPresObj() || dynamic_cast< const SdrGrafObj *>( pObj ) == nullptr ) )
+ pObj->AdjustToMaxRect(rRect);
+
+ return pObj;
+}
+
+/*************************************************************************
+|*
+|* Returns the PresObjKind of an object
+|*
+\************************************************************************/
+
+PresObjKind SdPage::GetPresObjKind(SdrObject* pObj) const
+{
+ PresObjKind eKind = PresObjKind::NONE;
+ if( (pObj != nullptr) && (maPresentationShapeList.hasShape(*pObj)) )
+ {
+ SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj);
+ if( pInfo )
+ eKind = pInfo->mePresObjKind;
+ }
+
+ return eKind;
+}
+
+bool SdPage::IsPresObj(const SdrObject* pObj)
+{
+ return pObj && maPresentationShapeList.hasShape( const_cast<SdrObject&>(*pObj) );
+}
+
+void SdPage::RemovePresObj(const SdrObject* pObj)
+{
+ if( pObj && maPresentationShapeList.hasShape(const_cast<SdrObject&>(*pObj)) )
+ {
+ SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(const_cast<SdrObject&>(*pObj));
+ if( pInfo )
+ pInfo->mePresObjKind = PresObjKind::NONE;
+ maPresentationShapeList.removeShape(const_cast<SdrObject&>(*pObj));
+ }
+}
+
+void SdPage::InsertPresObj(SdrObject* pObj, PresObjKind eKind )
+{
+ DBG_ASSERT( pObj, "sd::SdPage::InsertPresObj(), invalid presentation object inserted!" );
+ DBG_ASSERT( !IsPresObj(pObj), "sd::SdPage::InsertPresObj(), presentation object inserted twice!" );
+ if( pObj )
+ {
+ SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj, true);
+ if( pInfo )
+ pInfo->mePresObjKind = eKind;
+ maPresentationShapeList.addShape(*pObj);
+ }
+}
+
+/*************************************************************************
+|*
+|* Set the text of an object
+|*
+\************************************************************************/
+
+void SdPage::SetObjText(SdrTextObj* pObj, SdrOutliner* pOutliner, PresObjKind eObjKind, std::u16string_view rString )
+{
+ if ( !pObj )
+ return;
+
+ ::Outliner* pOutl = pOutliner;
+
+ if (!pOutliner)
+ {
+ SfxItemPool* pPool(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetDrawOutliner().GetEmptyItemSet().GetPool());
+ pOutl = new ::Outliner( pPool, OutlinerMode::OutlineObject );
+ pOutl->SetRefDevice( SD_MOD()->GetVirtualRefDevice() );
+ pOutl->SetEditTextObjectPool(pPool);
+ pOutl->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(getSdrModelFromSdrPage().GetStyleSheetPool()));
+ pOutl->EnableUndo(false);
+ pOutl->SetUpdateLayout( false );
+ }
+
+ OutlinerMode nOutlMode = pOutl->GetOutlinerMode();
+ Size aPaperSize = pOutl->GetPaperSize();
+ bool bUpdateMode = pOutl->SetUpdateLayout(false);
+ pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() );
+
+ // Always set the object's StyleSheet at the Outliner to
+ // use the current objects StyleSheet. Thus it's the same as in
+ // SetText(...).
+ // Moved this implementation from where SetObjText(...) was called
+ // to inside this method to work even when outliner is fetched here.
+ pOutl->SetStyleSheet(0, pObj->GetStyleSheet());
+
+ OUString aString;
+
+ switch( eObjKind )
+ {
+ case PresObjKind::Outline:
+ {
+ pOutl->Init( OutlinerMode::OutlineObject );
+
+ aString += OUString::Concat("\t") + rString;
+
+ if (mbMaster)
+ {
+ pOutl->SetStyleSheet( 0, GetStyleSheetForPresObj(eObjKind) );
+ aString += "\n\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER2) +
+ "\n\t\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER3) +
+ "\n\t\t\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER4) +
+ "\n\t\t\t\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER5) +
+ "\n\t\t\t\t\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER6) +
+ "\n\t\t\t\t\t\t\t" +
+ SdResId(STR_PRESOBJ_MPOUTLLAYER7);
+
+ }
+ }
+ break;
+
+ case PresObjKind::Title:
+ {
+ pOutl->Init( OutlinerMode::TitleObject );
+ aString += rString;
+ }
+ break;
+
+ default:
+ {
+ pOutl->Init( OutlinerMode::TextObject );
+ aString += rString;
+
+ // check if we need to add a text field
+ std::unique_ptr<SvxFieldData> pData;
+
+ switch( eObjKind )
+ {
+ case PresObjKind::Header:
+ pData.reset(new SvxHeaderField());
+ break;
+ case PresObjKind::Footer:
+ pData .reset(new SvxFooterField());
+ break;
+ case PresObjKind::SlideNumber:
+ pData.reset(new SvxPageField());
+ break;
+ case PresObjKind::DateTime:
+ pData.reset(new SvxDateTimeField());
+ break;
+ default:
+ break;
+ }
+
+ if( pData )
+ {
+ ESelection e;
+ SvxFieldItem aField( *pData, EE_FEATURE_FIELD );
+ pOutl->QuickInsertField(aField,e);
+ }
+ }
+ break;
+ }
+
+ pOutl->SetPaperSize( pObj->GetLogicRect().GetSize() );
+
+ if( !aString.isEmpty() )
+ pOutl->SetText( aString, pOutl->GetParagraph( 0 ) );
+
+ pObj->SetOutlinerParaObject( pOutl->CreateParaObject() );
+
+ if (!pOutliner)
+ {
+ delete pOutl;
+ pOutl = nullptr;
+ }
+ else
+ {
+ // restore the outliner
+ pOutl->Init( nOutlMode );
+ pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() );
+ pOutl->SetUpdateLayout( bUpdateMode );
+ pOutl->SetPaperSize( aPaperSize );
+ }
+}
+
+/*************************************************************************
+|*
+|* Set the name of the layout
+|*
+\************************************************************************/
+void SdPage::SetLayoutName(const OUString& aName)
+{
+ maLayoutName = aName;
+
+ if( mbMaster )
+ {
+ sal_Int32 nPos = maLayoutName.indexOf(SD_LT_SEPARATOR);
+ if (nPos != -1)
+ FmFormPage::SetName(maLayoutName.copy(0, nPos));
+ }
+}
+
+/*************************************************************************
+|*
+|* Return the page name and generates it if necessary
+|*
+\************************************************************************/
+
+const OUString& SdPage::GetName() const
+{
+ OUString aCreatedPageName( maCreatedPageName );
+ if (GetRealName().isEmpty())
+ {
+ if ((mePageKind == PageKind::Standard || mePageKind == PageKind::Notes) && !mbMaster)
+ {
+ // default name for handout pages
+ sal_uInt16 nNum = (GetPageNum() + 1) / 2;
+
+ aCreatedPageName = SdResId(STR_PAGE) + " ";
+ if (static_cast<SdDrawDocument&>(getSdrModelFromSdrPage()).GetDocumentType() == DocumentType::Draw )
+ aCreatedPageName = SdResId(STR_PAGE_NAME) + " ";
+
+ if( getSdrModelFromSdrPage().GetPageNumType() == css::style::NumberingType::NUMBER_NONE )
+ {
+ // if the document has number none as a formatting
+ // for page numbers we still default to arabic numbering
+ // to keep the default page names unique
+ aCreatedPageName += OUString::number( static_cast<sal_Int32>(nNum) );
+ }
+ else
+ {
+ aCreatedPageName += static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).CreatePageNumValue(nNum);
+ }
+ }
+ else
+ {
+ /******************************************************************
+ * default name for note pages
+ ******************************************************************/
+ aCreatedPageName = SdResId(STR_LAYOUT_DEFAULT_NAME);
+ }
+ }
+ else
+ {
+ aCreatedPageName = GetRealName();
+ }
+
+ if (mePageKind == PageKind::Notes)
+ {
+ aCreatedPageName += " " + SdResId(STR_NOTES);
+ }
+ else if (mePageKind == PageKind::Handout && mbMaster)
+ {
+ aCreatedPageName += " (" + SdResId(STR_HANDOUT) + ")";
+ }
+
+ const_cast< SdPage* >(this)->maCreatedPageName = aCreatedPageName;
+ return maCreatedPageName;
+}
+
+void SdPage::SetOrientation( Orientation /*eOrient*/)
+{
+ // Do nothing
+}
+
+Orientation SdPage::GetOrientation() const
+{
+ Size aSize = GetSize();
+ if ( aSize.getWidth() > aSize.getHeight() )
+ {
+ return Orientation::Landscape;
+ }
+ else
+ {
+ return Orientation::Portrait;
+ }
+}
+
+/*************************************************************************
+|*
+|* returns the default text of a PresObjektes
+|*
+\************************************************************************/
+
+OUString SdPage::GetPresObjText(PresObjKind eObjKind) const
+{
+ OUString aString;
+
+#if defined(IOS) || defined(ANDROID)
+ bool isMobileDevice = true;
+#else
+ bool isMobileDevice = false;
+ if (const SfxViewShell* pCurrentViewShell = SfxViewShell::Current())
+ isMobileDevice = pCurrentViewShell->isLOKMobilePhone() || pCurrentViewShell->isLOKTablet();
+#endif
+
+ if (eObjKind == PresObjKind::Title)
+ {
+ if (mbMaster)
+ {
+ if (mePageKind != PageKind::Notes)
+ {
+ if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_MPTITLE_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_MPTITLE);
+ }
+ else
+ {
+ if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_MPNOTESTITLE_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_MPNOTESTITLE);
+ }
+ }
+ else if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_TITLE_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_TITLE);
+ }
+ else if (eObjKind == PresObjKind::Outline)
+ {
+ if (mbMaster)
+ {
+ if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_MPOUTLINE_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_MPOUTLINE);
+ }
+ else if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_OUTLINE_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_OUTLINE);
+ }
+ else if (eObjKind == PresObjKind::Notes)
+ {
+ if (mbMaster)
+ {
+ if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_MPNOTESTEXT_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_MPNOTESTEXT);
+ }
+ else if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_NOTESTEXT_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_NOTESTEXT);
+ }
+ else if (eObjKind == PresObjKind::Text)
+ {
+ if (isMobileDevice)
+ aString = SdResId(STR_PRESOBJ_TEXT_MOBILE);
+ else
+ aString = SdResId(STR_PRESOBJ_TEXT);
+ }
+ else if (eObjKind == PresObjKind::Graphic)
+ {
+ aString = SdResId( STR_PRESOBJ_GRAPHIC );
+ }
+ else if (eObjKind == PresObjKind::Object)
+ {
+ aString = SdResId( STR_PRESOBJ_OBJECT );
+ }
+ else if (eObjKind == PresObjKind::Chart)
+ {
+ aString = SdResId( STR_PRESOBJ_CHART );
+ }
+ else if (eObjKind == PresObjKind::OrgChart)
+ {
+ aString = SdResId( STR_PRESOBJ_ORGCHART );
+ }
+ else if (eObjKind == PresObjKind::Calc)
+ {
+ aString = SdResId( STR_PRESOBJ_TABLE );
+ }
+
+ return aString;
+}
+
+uno::Reference< uno::XInterface > SdPage::createUnoPage()
+{
+ return createUnoPageImpl( this );
+}
+
+/** returns the SdPage implementation for the given XDrawPage or 0 if not available */
+SdPage* SdPage::getImplementation( const css::uno::Reference< css::drawing::XDrawPage >& xPage )
+{
+ try
+ {
+ auto pUnoPage = comphelper::getFromUnoTunnel<SvxDrawPage>(xPage);
+ if( pUnoPage )
+ return static_cast< SdPage* >( pUnoPage->GetSdrPage() );
+ }
+ catch( css::uno::Exception& )
+ {
+ TOOLS_WARN_EXCEPTION( "sd", "sd::SdPage::getImplementation()" );
+ }
+
+ return nullptr;
+}
+
+sal_Int64 SdPage::GetHashCode() const
+{
+ return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
+}
+
+void SdPage::SetName (const OUString& rName)
+{
+ OUString aOldName( GetName() );
+ FmFormPage::SetName (rName);
+ static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).UpdatePageRelativeURLs(aOldName, rName);
+ ActionChanged();
+}
+
+const HeaderFooterSettings& SdPage::getHeaderFooterSettings() const
+{
+ if( mePageKind == PageKind::Handout && !mbMaster )
+ {
+ return static_cast<SdPage&>(TRG_GetMasterPage()).maHeaderFooterSettings;
+ }
+ else
+ {
+ return maHeaderFooterSettings;
+ }
+}
+
+void SdPage::setHeaderFooterSettings( const sd::HeaderFooterSettings& rNewSettings )
+{
+ if( mePageKind == PageKind::Handout && !mbMaster )
+ {
+ static_cast<SdPage&>(TRG_GetMasterPage()).maHeaderFooterSettings = rNewSettings;
+ }
+ else
+ {
+ maHeaderFooterSettings = rNewSettings;
+ }
+
+ SetChanged();
+
+ if(!TRG_HasMasterPage())
+ return;
+
+ TRG_GetMasterPageDescriptorViewContact().ActionChanged();
+
+ // #i119056# For HeaderFooterSettings SdrObjects are used, but the properties
+ // used are not part of their model data, but kept in SD. This data is applied
+ // using a 'backdoor' on primitive creation. Thus, the normal mechanism to detect
+ // object changes does not work here. It is necessary to trigger updates here
+ // directly. BroadcastObjectChange used for PagePreview invalidations,
+ // flushViewObjectContacts used to invalidate and flush all visualizations in
+ // edit views.
+ SdPage* pMasterPage = dynamic_cast< SdPage* >(&TRG_GetMasterPage());
+
+ if(!pMasterPage)
+ return;
+
+ SdrObject* pCandidate = pMasterPage->GetPresObj( PresObjKind::Header );
+
+ if(pCandidate)
+ {
+ pCandidate->BroadcastObjectChange();
+ pCandidate->GetViewContact().flushViewObjectContacts();
+ }
+
+ pCandidate = pMasterPage->GetPresObj( PresObjKind::DateTime );
+
+ if(pCandidate)
+ {
+ pCandidate->BroadcastObjectChange();
+ pCandidate->GetViewContact().flushViewObjectContacts();
+ }
+
+ pCandidate = pMasterPage->GetPresObj( PresObjKind::Footer );
+
+ if(pCandidate)
+ {
+ pCandidate->BroadcastObjectChange();
+ pCandidate->GetViewContact().flushViewObjectContacts();
+ }
+
+ pCandidate = pMasterPage->GetPresObj( PresObjKind::SlideNumber );
+
+ if(pCandidate)
+ {
+ pCandidate->BroadcastObjectChange();
+ pCandidate->GetViewContact().flushViewObjectContacts();
+ }
+}
+
+bool SdPage::checkVisibility(
+ const sdr::contact::ViewObjectContact& rOriginal,
+ const sdr::contact::DisplayInfo& rDisplayInfo,
+ bool bEdit )
+{
+ if( !FmFormPage::checkVisibility( rOriginal, rDisplayInfo, bEdit ) )
+ return false;
+
+ SdrObject* pObj = rOriginal.GetViewContact().TryToGetSdrObject();
+ if( pObj == nullptr )
+ return false;
+
+ const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage());
+ const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter() || rOriginal.GetObjectContact().isOutputToPDFFile());
+ const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView();
+ const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage);
+
+ // empty presentation objects only visible during edit mode
+ if( (bIsPrinting || !bEdit || bIsInsidePageObj ) && pObj->IsEmptyPresObj() )
+ {
+ if( (pObj->GetObjInventor() != SdrInventor::Default) || ( (pObj->GetObjIdentifier() != SdrObjKind::Rectangle) && (pObj->GetObjIdentifier() != SdrObjKind::Page) ) )
+ return false;
+ }
+
+ if( ( pObj->GetObjInventor() == SdrInventor::Default ) && ( pObj->GetObjIdentifier() == SdrObjKind::Text ) )
+ {
+ const SdPage* pCheckPage = dynamic_cast< const SdPage* >(pObj->getSdrPageFromSdrObject());
+
+ if( pCheckPage )
+ {
+ PresObjKind eKind = pCheckPage->GetPresObjKind(pObj);
+
+ if((eKind == PresObjKind::Footer) || (eKind == PresObjKind::Header) || (eKind == PresObjKind::DateTime) || (eKind == PresObjKind::SlideNumber) )
+ {
+ const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive());
+
+ if( bSubContentProcessing || ( pCheckPage->GetPageKind() == PageKind::Handout && bIsPrinting ) )
+ {
+ // use the page that is currently processed
+ const SdPage* pVisualizedSdPage = dynamic_cast< const SdPage* >(pVisualizedPage);
+
+ if( pVisualizedSdPage )
+ {
+ // if we are not on a masterpage, see if we have to draw this header&footer object at all
+ const sd::HeaderFooterSettings& rSettings = pVisualizedSdPage->getHeaderFooterSettings();
+
+ switch( eKind )
+ {
+ case PresObjKind::Footer:
+ return rSettings.mbFooterVisible;
+ case PresObjKind::Header:
+ return rSettings.mbHeaderVisible;
+ case PresObjKind::DateTime:
+ return rSettings.mbDateTimeVisible;
+ case PresObjKind::SlideNumber:
+ return rSettings.mbSlideNumberVisible;
+ default:
+ break;
+ }
+ }
+ }
+ } // check for placeholders on master
+ else if( (eKind != PresObjKind::NONE) && pCheckPage->IsMasterPage() && ( pVisualizedPage != pCheckPage ) )
+ {
+ // presentation objects on master slide are always invisible if slide is shown.
+ return false;
+ }
+ }
+ }
+
+ // i63977, do not print SdrpageObjs from master pages
+ if( ( pObj->GetObjInventor() == SdrInventor::Default ) && ( pObj->GetObjIdentifier() == SdrObjKind::Page ) )
+ {
+ if( pObj->getSdrPageFromSdrObject() && pObj->getSdrPageFromSdrObject()->IsMasterPage() )
+ return false;
+ }
+
+ return true;
+}
+
+bool SdPage::RestoreDefaultText( SdrObject* pObj )
+{
+ bool bRet = false;
+
+ SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
+
+ if( pTextObj )
+ {
+ PresObjKind ePresObjKind = GetPresObjKind(pTextObj);
+
+ if (ePresObjKind == PresObjKind::Title ||
+ ePresObjKind == PresObjKind::Outline ||
+ ePresObjKind == PresObjKind::Notes ||
+ ePresObjKind == PresObjKind::Text)
+ {
+ OUString aString( GetPresObjText(ePresObjKind) );
+
+ if (!aString.isEmpty())
+ {
+ bool bVertical = false;
+ OutlinerParaObject* pOldPara = pTextObj->GetOutlinerParaObject();
+ if( pOldPara )
+ bVertical = pOldPara->IsEffectivelyVertical(); // is old para object vertical?
+
+ SetObjText( pTextObj, nullptr, ePresObjKind, aString );
+
+ if( pOldPara )
+ {
+ // Here, only the vertical flag for the
+ // OutlinerParaObjects needs to be changed. The
+ // AutoGrowWidth/Height items still exist in the
+ // not changed object.
+ if(pTextObj->GetOutlinerParaObject()
+ && pTextObj->GetOutlinerParaObject()->IsEffectivelyVertical() != bVertical)
+ {
+ ::tools::Rectangle aObjectRect = pTextObj->GetSnapRect();
+ pTextObj->GetOutlinerParaObject()->SetVertical(bVertical);
+ pTextObj->SetSnapRect(aObjectRect);
+ }
+ }
+
+ pTextObj->SetTextEditOutliner( nullptr ); // to make stylesheet settings work
+ pTextObj->NbcSetStyleSheet( GetStyleSheetForPresObj(ePresObjKind), true );
+ pTextObj->SetEmptyPresObj(true);
+ bRet = true;
+ }
+ }
+ }
+ return bRet;
+}
+
+void SdPage::CalculateHandoutAreas( SdDrawDocument& rModel, AutoLayout eLayout, bool bHorizontal, std::vector< ::tools::Rectangle >& rAreas )
+{
+ SdPage& rHandoutMaster = *rModel.GetMasterSdPage( 0, PageKind::Handout );
+
+ static const sal_uInt16 aOffsets[5][9] =
+ {
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, // AUTOLAYOUT_HANDOUT9, Portrait, Horizontal order
+ { 0, 2, 4, 1, 3, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT3, Landscape, Vertical
+ { 0, 2, 1, 3, 0, 0, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Landscape, Vertical
+ { 0, 3, 1, 4, 2, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Portrait, Vertical
+ { 0, 3, 6, 1, 4, 7, 2, 5, 8 }, // AUTOLAYOUT_HANDOUT9, Landscape, Vertical
+ };
+
+ const sal_uInt16* pOffsets = aOffsets[0];
+
+ Size aArea = rHandoutMaster.GetSize();
+ const bool bLandscape = aArea.Width() > aArea.Height();
+
+ if( eLayout == AUTOLAYOUT_NONE )
+ {
+ // use layout from handout master
+ SdrObjListIter aShapeIter(&rHandoutMaster);
+
+ std::vector< ::tools::Rectangle > vSlidesAreas;
+ while ( aShapeIter.IsMore() )
+ {
+ SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>( aShapeIter.Next() );
+ // get slide rectangles
+ if (pPageObj)
+ vSlidesAreas.push_back( pPageObj->GetCurrentBoundRect() );
+ }
+
+ if ( !bHorizontal || vSlidesAreas.size() < 4 )
+ { // top to bottom, then right
+ rAreas.swap( vSlidesAreas );
+ }
+ else
+ { // left to right, then down
+ switch ( vSlidesAreas.size() )
+ {
+ case 4:
+ pOffsets = aOffsets[2];
+ break;
+
+ default:
+ [[fallthrough]];
+ case 6:
+ pOffsets = aOffsets[ bLandscape ? 3 : 1 ];
+ break;
+
+ case 9:
+ pOffsets = aOffsets[4];
+ break;
+ }
+
+ rAreas.resize( static_cast<size_t>(vSlidesAreas.size()) );
+
+ for( const ::tools::Rectangle& rRect : vSlidesAreas )
+ {
+ rAreas[*pOffsets++] = rRect;
+ }
+ }
+ }
+ else
+ {
+ const ::tools::Long nGapW = 1000; // gap is 1cm
+ const ::tools::Long nGapH = 1000;
+
+ ::tools::Long nLeftBorder = rHandoutMaster.GetLeftBorder();
+ ::tools::Long nRightBorder = rHandoutMaster.GetRightBorder();
+ ::tools::Long nTopBorder = rHandoutMaster.GetUpperBorder();
+ ::tools::Long nBottomBorder = rHandoutMaster.GetLowerBorder();
+
+ const ::tools::Long nHeaderFooterHeight = static_cast< ::tools::Long >( (aArea.Height() - nTopBorder - nLeftBorder) * 0.05 );
+
+ nTopBorder += nHeaderFooterHeight;
+ nBottomBorder += nHeaderFooterHeight;
+
+ ::tools::Long nX = nGapW + nLeftBorder;
+ ::tools::Long nY = nGapH + nTopBorder;
+
+ aArea.AdjustWidth( -(nGapW * 2 + nLeftBorder + nRightBorder) );
+ aArea.AdjustHeight( -(nGapH * 2 + nTopBorder + nBottomBorder) );
+
+ sal_uInt16 nColCnt = 0, nRowCnt = 0;
+ switch ( eLayout )
+ {
+ case AUTOLAYOUT_HANDOUT1:
+ nColCnt = 1; nRowCnt = 1;
+ break;
+
+ case AUTOLAYOUT_HANDOUT2:
+ if( bLandscape )
+ {
+ nColCnt = 2; nRowCnt = 1;
+ }
+ else
+ {
+ nColCnt = 1; nRowCnt = 2;
+ }
+ break;
+
+ case AUTOLAYOUT_HANDOUT3:
+ if( bLandscape )
+ {
+ nColCnt = 3; nRowCnt = 2;
+ }
+ else
+ {
+ nColCnt = 2; nRowCnt = 3;
+ }
+ pOffsets = aOffsets[ bLandscape ? 1 : 0 ];
+ break;
+
+ case AUTOLAYOUT_HANDOUT4:
+ nColCnt = 2; nRowCnt = 2;
+ pOffsets = aOffsets[ bHorizontal ? 0 : 2 ];
+ break;
+
+ case AUTOLAYOUT_HANDOUT6:
+ if( bLandscape )
+ {
+ nColCnt = 3; nRowCnt = 2;
+ }
+ else
+ {
+ nColCnt = 2; nRowCnt = 3;
+ }
+ if( !bHorizontal )
+ pOffsets = aOffsets[ bLandscape ? 1 : 3 ];
+ break;
+
+ default:
+ case AUTOLAYOUT_HANDOUT9:
+ nColCnt = 3; nRowCnt = 3;
+
+ if( !bHorizontal )
+ pOffsets = aOffsets[4];
+ break;
+ }
+
+ rAreas.resize(static_cast<size_t>(nColCnt) * nRowCnt);
+
+ Size aPartArea, aSize;
+ aPartArea.setWidth( (aArea.Width() - ((nColCnt-1) * nGapW) ) / nColCnt );
+ aPartArea.setHeight( (aArea.Height() - ((nRowCnt-1) * nGapH) ) / nRowCnt );
+
+ SdrPage* pFirstPage = rModel.GetMasterSdPage(0, PageKind::Standard);
+ if (pFirstPage && pFirstPage->GetWidth() && pFirstPage->GetHeight())
+ {
+ // scale actual size into handout rect
+ double fScale = static_cast<double>(aPartArea.Width()) / static_cast<double>(pFirstPage->GetWidth());
+
+ aSize.setHeight( static_cast<::tools::Long>(fScale * pFirstPage->GetHeight() ) );
+ if( aSize.Height() > aPartArea.Height() )
+ {
+ fScale = static_cast<double>(aPartArea.Height()) / static_cast<double>(pFirstPage->GetHeight());
+ aSize.setHeight( aPartArea.Height() );
+ aSize.setWidth( static_cast<::tools::Long>(fScale * pFirstPage->GetWidth()) );
+ }
+ else
+ {
+ aSize.setWidth( aPartArea.Width() );
+ }
+
+ nX += (aPartArea.Width() - aSize.Width()) / 2;
+ nY += (aPartArea.Height()- aSize.Height())/ 2;
+ }
+ else
+ {
+ aSize = aPartArea;
+ }
+
+ Point aPos( nX, nY );
+
+ const bool bRTL = rModel.GetDefaultWritingMode() == css::text::WritingMode_RL_TB;
+
+ const ::tools::Long nOffsetX = (aPartArea.Width() + nGapW) * (bRTL ? -1 : 1);
+ const ::tools::Long nOffsetY = aPartArea.Height() + nGapH;
+ const ::tools::Long nStartX = bRTL ? nOffsetX*(1 - nColCnt) + nX : nX;
+
+ for(sal_uInt16 nRow = 0; nRow < nRowCnt; nRow++)
+ {
+ aPos.setX( nStartX );
+ for(sal_uInt16 nCol = 0; nCol < nColCnt; nCol++)
+ {
+ rAreas[*pOffsets++] = ::tools::Rectangle(aPos, aSize);
+ aPos.AdjustX(nOffsetX );
+ }
+
+ aPos.AdjustY(nOffsetY );
+ }
+ }
+}
+
+void SdPage::SetPrecious (const bool bIsPrecious)
+{
+ mbIsPrecious = bIsPrecious;
+}
+
+HeaderFooterSettings::HeaderFooterSettings()
+{
+ mbHeaderVisible = true;
+ mbFooterVisible = true;
+ mbSlideNumberVisible = false;
+ mbDateTimeVisible = true;
+ mbDateTimeIsFixed = true;
+ meDateFormat = SvxDateFormat::A;
+ meTimeFormat = SvxTimeFormat::AppDefault;
+}
+
+bool HeaderFooterSettings::operator==( const HeaderFooterSettings& rSettings ) const
+{
+ return (mbHeaderVisible == rSettings.mbHeaderVisible) &&
+ (maHeaderText == rSettings.maHeaderText) &&
+ (mbFooterVisible == rSettings.mbFooterVisible) &&
+ (maFooterText == rSettings.maFooterText) &&
+ (mbSlideNumberVisible == rSettings.mbSlideNumberVisible) &&
+ (mbDateTimeVisible == rSettings.mbDateTimeVisible) &&
+ (mbDateTimeIsFixed == rSettings.mbDateTimeIsFixed) &&
+ (meDateFormat == rSettings.meDateFormat) &&
+ (meTimeFormat == rSettings.meTimeFormat) &&
+ (maDateTimeText == rSettings.maDateTimeText);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-12 14:21:09 +0000