summaryrefslogtreecommitdiffstats
path: root/sd/source/core/drawdoc.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'sd/source/core/drawdoc.cxx')
-rw-r--r--sd/source/core/drawdoc.cxx1206
1 files changed, 1206 insertions, 0 deletions
diff --git a/sd/source/core/drawdoc.cxx b/sd/source/core/drawdoc.cxx
new file mode 100644
index 000000000..182ffe7f2
--- /dev/null
+++ b/sd/source/core/drawdoc.cxx
@@ -0,0 +1,1206 @@
+/* -*- 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 <libxml/xmlwriter.h>
+
+#include "PageListWatcher.hxx"
+#include <com/sun/star/document/PrinterIndependentLayout.hpp>
+#include <com/sun/star/i18n/ScriptType.hpp>
+#include <com/sun/star/beans/XPropertyContainer.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <editeng/forbiddencharacterstable.hxx>
+
+#include <svl/srchitem.hxx>
+#include <editeng/eeitem.hxx>
+#include <editeng/scriptspaceitem.hxx>
+#include <tools/debug.hxx>
+
+#include <unotools/configmgr.hxx>
+#include <unotools/useroptions.hxx>
+#include <officecfg/Office/Impress.hxx>
+
+#include <sfx2/linkmgr.hxx>
+#include <Outliner.hxx>
+#include <sdmod.hxx>
+#include <editeng/editstat.hxx>
+#include <svx/svdotext.hxx>
+#include <editeng/unolingu.hxx>
+#include <svl/itempool.hxx>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <editeng/outlobj.hxx>
+#include <comphelper/getexpandeduri.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <unotools/charclass.hxx>
+#include <comphelper/processfactory.hxx>
+#include <unotools/lingucfg.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
+#include <com/sun/star/xml/dom/XDocument.hpp>
+#include <com/sun/star/xml/dom/XNodeList.hpp>
+#include <com/sun/star/xml/dom/DocumentBuilder.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <rtl/ustring.hxx>
+
+#include <editeng/outliner.hxx>
+#include <drawdoc.hxx>
+#include <sdpage.hxx>
+#include <strings.hrc>
+#include <glob.hxx>
+#include <stlpool.hxx>
+#include <sdresid.hxx>
+#include <customshowlist.hxx>
+#include <DrawDocShell.hxx>
+#include <GraphicDocShell.hxx>
+#include <sdxfer.hxx>
+#include <optsitem.hxx>
+#include <FrameView.hxx>
+#include <undo/undomanager.hxx>
+#include <sdundogr.hxx>
+#include <undopage.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <unokywds.hxx>
+
+namespace com::sun::star::linguistic2 { class XHyphenator; }
+namespace com::sun::star::linguistic2 { class XSpellChecker1; }
+
+using namespace ::sd;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::linguistic2;
+
+using namespace com::sun::star::xml::dom;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::lang::XMultiServiceFactory;
+
+
+SdDrawDocument* SdDrawDocument::s_pDocLockedInsertingLinks = nullptr;
+
+PresentationSettings::PresentationSettings()
+: mbAll( true ),
+ mbEndless( false ),
+ mbCustomShow(false),
+ mbManual( false ),
+ mbMouseVisible( false ),
+ mbMouseAsPen( false ),
+ mbLockedPages( false ),
+ mbAlwaysOnTop( false ),
+ mbFullScreen( true ),
+ mbAnimationAllowed( true ),
+ mnPauseTimeout( 0 ),
+ mbShowPauseLogo( false ),
+ mbStartCustomShow( false )
+{
+}
+
+SdDrawDocument::SdDrawDocument(DocumentType eType, SfxObjectShell* pDrDocSh)
+: FmFormModel(
+ nullptr,
+ pDrDocSh)
+, mpDocSh(static_cast< ::sd::DrawDocShell*>(pDrDocSh))
+, mpCreatingTransferable( nullptr )
+, mbHasOnlineSpellErrors(false)
+, mbInitialOnlineSpellingEnabled(true)
+, mbNewOrLoadCompleted(false)
+, mbOnlineSpell(false)
+, mbStartWithPresentation( false )
+, mbExitAfterPresenting( false )
+, meLanguage( LANGUAGE_SYSTEM )
+, meLanguageCJK( LANGUAGE_SYSTEM )
+, meLanguageCTL( LANGUAGE_SYSTEM )
+, mePageNumType(SVX_NUM_ARABIC)
+, mbAllocDocSh(false)
+, meDocType(eType)
+, mbEmbedFonts(false)
+, mbEmbedUsedFontsOnly(false)
+, mbEmbedFontScriptLatin(true)
+, mbEmbedFontScriptAsian(true)
+, mbEmbedFontScriptComplex(true)
+, mnImagePreferredDPI(0)
+{
+ mpDrawPageListWatcher.reset(new ImpDrawPageListWatcher(*this));
+ mpMasterPageListWatcher.reset(new ImpMasterPageListWatcher(*this));
+
+ InitLayoutVector();
+ InitObjectVector();
+ SetObjectShell(pDrDocSh); // for VCDrawModel
+
+ if (mpDocSh)
+ {
+ SetSwapGraphics();
+ }
+
+ // Set measuring unit (of the application) and scale (of SdMod)
+ sal_Int32 nX, nY;
+ SdOptions* pOptions = SD_MOD()->GetSdOptions(meDocType);
+ pOptions->GetScale( nX, nY );
+
+ // Allow UI scale only for draw documents.
+ if( eType == DocumentType::Draw )
+ SetUIUnit( static_cast<FieldUnit>(pOptions->GetMetric()), Fraction( nX, nY ) ); // user-defined
+ else
+ SetUIUnit( static_cast<FieldUnit>(pOptions->GetMetric()), Fraction( 1, 1 ) ); // default
+
+ SetScaleUnit(MapUnit::Map100thMM);
+ SetScaleFraction(Fraction(1, 1));
+ SetDefaultFontHeight(o3tl::convert(24, o3tl::Length::pt, o3tl::Length::mm100));
+
+ m_pItemPool->SetDefaultMetric(MapUnit::Map100thMM);
+ m_pItemPool->FreezeIdRanges();
+ SetTextDefaults();
+
+ // DrawingEngine has to know where it is...
+ FmFormModel::SetStyleSheetPool( new SdStyleSheetPool( GetPool(), this ) );
+
+ // Set StyleSheetPool for DrawOutliner, so text objects can be read correctly.
+ // The link to the StyleRequest handler of the document is set later, in
+ // NewOrLoadCompleted, because only then do all the templates exist.
+ SdrOutliner& rOutliner = GetDrawOutliner();
+ rOutliner.SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ SetCalcFieldValueHdl( &rOutliner );
+
+ // set linguistic options
+ if (!utl::ConfigManager::IsFuzzing())
+ {
+ const SvtLinguConfig aLinguConfig;
+ SvtLinguOptions aOptions;
+ aLinguConfig.GetOptions( aOptions );
+
+ SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage,
+ css::i18n::ScriptType::LATIN), EE_CHAR_LANGUAGE );
+ SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CJK,
+ css::i18n::ScriptType::ASIAN), EE_CHAR_LANGUAGE_CJK );
+ SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CTL,
+ css::i18n::ScriptType::COMPLEX), EE_CHAR_LANGUAGE_CTL );
+
+ mbOnlineSpell = aOptions.bIsSpellAuto;
+ }
+
+ LanguageType eRealLanguage = MsLangId::getRealLanguage( meLanguage );
+ mpCharClass.reset(new CharClass( LanguageTag( eRealLanguage) ));
+
+ // If the current application language is a language that uses right-to-left text...
+ LanguageType eRealCTLLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
+
+ // for korean and japanese languages we have a different default for apply spacing between asian, latin and ctl text
+ if (MsLangId::isKorean(eRealCTLLanguage) || (LANGUAGE_JAPANESE == eRealCTLLanguage))
+ {
+ GetPool().GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
+ }
+
+ // Set DefTab and SpellOptions for the SD module
+ sal_uInt16 nDefTab = pOptions->GetDefTab();
+ SetDefaultTabulator( nDefTab );
+
+ try
+ {
+ Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
+ if ( xSpellChecker.is() )
+ rOutliner.SetSpeller( xSpellChecker );
+
+ Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
+ if( xHyphenator.is() )
+ rOutliner.SetHyphenator( xHyphenator );
+
+ SetForbiddenCharsTable(SvxForbiddenCharactersTable::makeForbiddenCharactersTable(::comphelper::getProcessComponentContext()));
+ }
+ catch(...)
+ {
+ OSL_FAIL("Can't get SpellChecker");
+ }
+
+ rOutliner.SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
+
+ if (mpDocSh)
+ {
+ SetLinkManager( new sfx2::LinkManager(mpDocSh) );
+ }
+
+ EEControlBits nCntrl = rOutliner.GetControlWord();
+ nCntrl |= EEControlBits::ALLOWBIGOBJS;
+
+ if (mbOnlineSpell)
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+
+ nCntrl &= ~ EEControlBits::ULSPACESUMMATION;
+ if ( meDocType != DocumentType::Impress )
+ SetSummationOfParagraphs( false );
+ else
+ {
+ SetSummationOfParagraphs( pOptions->IsSummationOfParagraphs() );
+ if ( pOptions->IsSummationOfParagraphs() )
+ nCntrl |= EEControlBits::ULSPACESUMMATION;
+ }
+ rOutliner.SetControlWord(nCntrl);
+
+ // Initialize the printer independent layout mode
+ SetPrinterIndependentLayout (pOptions->GetPrinterIndependentLayout());
+
+ // Set the StyleSheetPool for HitTestOutliner.
+ // The link to the StyleRequest handler of the document is set later, in
+ // NewOrLoadCompleted, because only then do all the templates exist.
+ m_pHitTestOutliner->SetStyleSheetPool( static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()) );
+
+ SetCalcFieldValueHdl( m_pHitTestOutliner.get() );
+
+ try
+ {
+ Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
+ if ( xSpellChecker.is() )
+ m_pHitTestOutliner->SetSpeller( xSpellChecker );
+
+ Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
+ if( xHyphenator.is() )
+ m_pHitTestOutliner->SetHyphenator( xHyphenator );
+ }
+ catch(...)
+ {
+ OSL_FAIL("Can't get SpellChecker");
+ }
+
+ m_pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
+
+ EEControlBits nCntrl2 = m_pHitTestOutliner->GetControlWord();
+ nCntrl2 |= EEControlBits::ALLOWBIGOBJS;
+ nCntrl2 &= ~EEControlBits::ONLINESPELLING;
+
+ nCntrl2 &= ~ EEControlBits::ULSPACESUMMATION;
+ if ( pOptions->IsSummationOfParagraphs() )
+ nCntrl2 |= EEControlBits::ULSPACESUMMATION;
+
+ m_pHitTestOutliner->SetControlWord( nCntrl2 );
+
+ /** Create layers
+ *
+ * We create the following default layers on all pages and master pages:
+ *
+ * sUNO_LayerName_layout; "layout": default layer for drawing objects of normal pages
+ * localized by SdResId(STR_LAYER_LAYOUT)
+ *
+ * sUNO_LayerName_background; "background": background of the master page
+ * localized by SdResId(STR_LAYER_BCKGRND)
+ * (currently unused within normal pages and not visible to users)
+ *
+ * sUNO_LayerName_background_objects; "backgroundobjects": objects on the background of master pages
+ * localized by SdResId(STR_LAYER_BCKGRNDOBJ)
+ * (currently unused within normal pages)
+ *
+ * sUNO_LayerName_controls; "controls": default layer for controls
+ * localized by SdResId(STR_LAYER_CONTROLS)
+ * (currently special handling in regard to z-order)
+ *
+ * sUNO_LayerName_measurelines; "measurelines" : default layer for measure lines
+ * localized by SdResId(STR_LAYER_MEASURELINES)
+ */
+
+ {
+ SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
+ rLayerAdmin.NewLayer( sUNO_LayerName_layout );
+ rLayerAdmin.NewLayer( sUNO_LayerName_background );
+ rLayerAdmin.NewLayer( sUNO_LayerName_background_objects );
+ rLayerAdmin.NewLayer( sUNO_LayerName_controls);
+ rLayerAdmin.NewLayer( sUNO_LayerName_measurelines );
+
+ rLayerAdmin.SetControlLayerName(sUNO_LayerName_controls);
+ }
+
+}
+
+// Destructor
+SdDrawDocument::~SdDrawDocument()
+{
+ Broadcast(SdrHint(SdrHintKind::ModelCleared));
+
+ if (mpWorkStartupTimer)
+ {
+ if ( mpWorkStartupTimer->IsActive() )
+ mpWorkStartupTimer->Stop();
+
+ mpWorkStartupTimer.reset();
+ }
+
+ StopOnlineSpelling();
+ mpOnlineSearchItem.reset();
+
+ CloseBookmarkDoc();
+ SetAllocDocSh(false);
+
+ ClearModel(true);
+
+ if (m_pLinkManager)
+ {
+ // Release BaseLinks
+ if ( !m_pLinkManager->GetLinks().empty() )
+ {
+ m_pLinkManager->Remove( 0, m_pLinkManager->GetLinks().size() );
+ }
+
+ delete m_pLinkManager;
+ m_pLinkManager = nullptr;
+ }
+
+ maFrameViewList.clear();
+ mpCustomShowList.reset();
+ mpOutliner.reset();
+ mpInternalOutliner.reset();
+ mpCharClass.reset();
+}
+
+void SdDrawDocument::adaptSizeAndBorderForAllPages(
+ const Size& rNewSize,
+ ::tools::Long nLeft,
+ ::tools::Long nRight,
+ ::tools::Long nUpper,
+ ::tools::Long nLower)
+{
+ const sal_uInt16 nMasterPageCnt(GetMasterSdPageCount(PageKind::Standard));
+ const sal_uInt16 nPageCnt(GetSdPageCount(PageKind::Standard));
+
+ if(0 == nMasterPageCnt && 0 == nPageCnt)
+ {
+ return;
+ }
+
+ SdPage* pPage(0 != nPageCnt ? GetSdPage(0, PageKind::Standard) : GetMasterSdPage(0, PageKind::Standard));
+
+ // call fully implemented local version, including getting
+ // some more information from one of the Pages (1st one)
+ AdaptPageSizeForAllPages(
+ rNewSize,
+ PageKind::Standard,
+ nullptr,
+ nLeft,
+ nRight,
+ nUpper,
+ nLower,
+ true,
+ pPage->GetOrientation(),
+ pPage->GetPaperBin(),
+ pPage->IsBackgroundFullSize());
+
+ // adjust handout page to new format of the standard page
+ if(0 != nPageCnt)
+ {
+ GetSdPage(0, PageKind::Handout)->CreateTitleAndLayout(true);
+ }
+}
+
+void SdDrawDocument::AdaptPageSizeForAllPages(
+ const Size& rNewSize,
+ PageKind ePageKind,
+ SdUndoGroup* pUndoGroup,
+ ::tools::Long nLeft,
+ ::tools::Long nRight,
+ ::tools::Long nUpper,
+ ::tools::Long nLower,
+ bool bScaleAll,
+ Orientation eOrientation,
+ sal_uInt16 nPaperBin,
+ bool bBackgroundFullSize)
+{
+ sal_uInt16 i;
+ const sal_uInt16 nMasterPageCnt(GetMasterSdPageCount(ePageKind));
+ const sal_uInt16 nPageCnt(GetSdPageCount(ePageKind));
+
+ if(0 == nMasterPageCnt && 0 == nPageCnt)
+ {
+ return;
+ }
+
+ for (i = 0; i < nMasterPageCnt; i++)
+ {
+ // first, handle all master pages
+ SdPage* pPage(GetMasterSdPage(i, ePageKind));
+
+ if(pUndoGroup)
+ {
+ SdUndoAction* pUndo(
+ new SdPageFormatUndoAction(
+ this,
+ pPage,
+ pPage->GetSize(),
+ pPage->GetLeftBorder(), pPage->GetRightBorder(),
+ pPage->GetUpperBorder(), pPage->GetLowerBorder(),
+ pPage->GetOrientation(),
+ pPage->GetPaperBin(),
+ pPage->IsBackgroundFullSize(),
+ rNewSize,
+ nLeft, nRight,
+ nUpper, nLower,
+ bScaleAll,
+ eOrientation,
+ nPaperBin,
+ bBackgroundFullSize));
+ pUndoGroup->AddAction(pUndo);
+ }
+
+ if (rNewSize.Width() > 0 || nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
+ {
+ ::tools::Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
+ pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
+
+ if (rNewSize.Width() > 0)
+ {
+ pPage->SetSize(rNewSize);
+ }
+ }
+
+ if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
+ {
+ pPage->SetBorder(nLeft, nUpper, nRight, nLower);
+ }
+
+ pPage->SetOrientation(eOrientation);
+ pPage->SetPaperBin( nPaperBin );
+ pPage->SetBackgroundFullSize( bBackgroundFullSize );
+
+ if ( ePageKind == PageKind::Standard )
+ {
+ GetMasterSdPage(i, PageKind::Notes)->CreateTitleAndLayout();
+ }
+
+ pPage->CreateTitleAndLayout();
+ }
+
+ for (i = 0; i < nPageCnt; i++)
+ {
+ // then, handle all pages
+ SdPage* pPage(GetSdPage(i, ePageKind));
+
+ if(pUndoGroup)
+ {
+ SdUndoAction* pUndo(
+ new SdPageFormatUndoAction(
+ this,
+ pPage,
+ pPage->GetSize(),
+ pPage->GetLeftBorder(), pPage->GetRightBorder(),
+ pPage->GetUpperBorder(), pPage->GetLowerBorder(),
+ pPage->GetOrientation(),
+ pPage->GetPaperBin(),
+ pPage->IsBackgroundFullSize(),
+ rNewSize,
+ nLeft, nRight,
+ nUpper, nLower,
+ bScaleAll,
+ eOrientation,
+ nPaperBin,
+ bBackgroundFullSize));
+ pUndoGroup->AddAction(pUndo);
+ }
+
+ if (rNewSize.Width() > 0 || nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
+ {
+ ::tools::Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
+ pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
+
+ if (rNewSize.Width() > 0)
+ {
+ pPage->SetSize(rNewSize);
+ }
+ }
+
+ if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
+ {
+ pPage->SetBorder(nLeft, nUpper, nRight, nLower);
+ }
+
+ pPage->SetOrientation(eOrientation);
+ pPage->SetPaperBin( nPaperBin );
+ pPage->SetBackgroundFullSize( bBackgroundFullSize );
+
+ if ( ePageKind == PageKind::Standard )
+ {
+ SdPage* pNotesPage = GetSdPage(i, PageKind::Notes);
+ pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
+ }
+
+ pPage->SetAutoLayout( pPage->GetAutoLayout() );
+ }
+}
+
+SdrModel* SdDrawDocument::AllocModel() const
+{
+ return AllocSdDrawDocument();
+}
+
+namespace
+{
+
+/// Copies all user-defined properties from pSource to pDestination.
+void lcl_copyUserDefinedProperties(const SfxObjectShell* pSource, const SfxObjectShell* pDestination)
+{
+ if (!pSource || !pDestination)
+ return;
+
+ uno::Reference<document::XDocumentProperties> xSource = pSource->getDocProperties();
+ uno::Reference<document::XDocumentProperties> xDestination = pDestination->getDocProperties();
+ uno::Reference<beans::XPropertyContainer> xSourcePropertyContainer = xSource->getUserDefinedProperties();
+ uno::Reference<beans::XPropertyContainer> xDestinationPropertyContainer = xDestination->getUserDefinedProperties();
+ uno::Reference<beans::XPropertySet> xSourcePropertySet(xSourcePropertyContainer, uno::UNO_QUERY);
+ const uno::Sequence<beans::Property> aProperties = xSourcePropertySet->getPropertySetInfo()->getProperties();
+
+ for (const beans::Property& rProperty : aProperties)
+ {
+ const OUString& rKey = rProperty.Name;
+ uno::Any aValue = xSourcePropertySet->getPropertyValue(rKey);
+ // We know that pDestination was just created, so has no properties: addProperty() will never throw.
+ xDestinationPropertyContainer->addProperty(rKey, beans::PropertyAttribute::REMOVABLE, aValue);
+ }
+}
+
+}
+
+// This method creates a new document (SdDrawDocument) and returns a pointer to
+// said document. The drawing engine uses this method to put the document (or
+// parts of it) into the clipboard/DragServer.
+SdDrawDocument* SdDrawDocument::AllocSdDrawDocument() const
+{
+ SdDrawDocument* pNewModel = nullptr;
+
+ if( mpCreatingTransferable )
+ {
+ // Document is created for drag & drop/clipboard. To be able to
+ // do this, the document has to know a DocShell (SvPersist).
+ SfxObjectShell* pObj = nullptr;
+ ::sd::DrawDocShell* pNewDocSh = nullptr;
+
+ if( meDocType == DocumentType::Impress )
+ mpCreatingTransferable->SetDocShell( new ::sd::DrawDocShell(
+ SfxObjectCreateMode::EMBEDDED, true, meDocType ) );
+ else
+ mpCreatingTransferable->SetDocShell( new ::sd::GraphicDocShell(
+ SfxObjectCreateMode::EMBEDDED ) );
+
+ pObj = mpCreatingTransferable->GetDocShell().get();
+ pNewDocSh = static_cast< ::sd::DrawDocShell*>( pObj );
+ pNewDocSh->DoInitNew();
+ pNewModel = pNewDocSh->GetDoc();
+
+ // Only necessary for clipboard -
+ // for drag & drop this is handled by DragServer
+ SdStyleSheetPool* pOldStylePool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() );
+ SdStyleSheetPool* pNewStylePool = static_cast<SdStyleSheetPool*>( pNewModel->GetStyleSheetPool() );
+
+ pNewStylePool->CopyGraphicSheets(*pOldStylePool);
+ pNewStylePool->CopyCellSheets(*pOldStylePool);
+ pNewStylePool->CopyTableStyles(*pOldStylePool);
+
+ for (sal_uInt16 i = 0; i < GetMasterSdPageCount(PageKind::Standard); i++)
+ {
+ // Move with all of the master page's layouts
+ OUString aOldLayoutName(const_cast<SdDrawDocument*>(this)->GetMasterSdPage(i, PageKind::Standard)->GetLayoutName());
+ aOldLayoutName = aOldLayoutName.copy( 0, aOldLayoutName.indexOf( SD_LT_SEPARATOR ) );
+ StyleSheetCopyResultVector aCreatedSheets;
+ pNewStylePool->CopyLayoutSheets(aOldLayoutName, *pOldStylePool, aCreatedSheets );
+ }
+
+ lcl_copyUserDefinedProperties(GetDocSh(), pNewDocSh);
+
+ pNewModel->NewOrLoadCompleted( DocCreationMode::Loaded ); // loaded from source document
+ }
+ else if( mbAllocDocSh )
+ {
+ // Create a DocShell which is then returned with GetAllocedDocSh()
+ SdDrawDocument* pDoc = const_cast<SdDrawDocument*>(this);
+ pDoc->SetAllocDocSh(false);
+ pDoc->mxAllocedDocShRef = new ::sd::DrawDocShell(
+ SfxObjectCreateMode::EMBEDDED, true, meDocType);
+ pDoc->mxAllocedDocShRef->DoInitNew();
+ pNewModel = pDoc->mxAllocedDocShRef->GetDoc();
+ }
+ else
+ {
+ pNewModel = new SdDrawDocument(meDocType, nullptr);
+ }
+
+ return pNewModel;
+}
+
+rtl::Reference<SdPage> SdDrawDocument::AllocSdPage(bool bMasterPage)
+{
+ return new SdPage(*this, bMasterPage);
+}
+
+// This method creates a new page (SdPage) and returns a pointer to said page.
+// The drawing engine uses this method to create pages (whose types it does
+// not know, as they are _derivatives_ of SdrPage) when loading.
+rtl::Reference<SdrPage> SdDrawDocument::AllocPage(bool bMasterPage)
+{
+ return AllocSdPage(bMasterPage);
+}
+
+// When the model has changed
+void SdDrawDocument::SetChanged(bool bFlag)
+{
+ if (mpDocSh)
+ {
+ if (mbNewOrLoadCompleted && mpDocSh->IsEnableSetModified())
+ {
+ // Pass on to base class
+ FmFormModel::SetChanged(bFlag);
+
+ // Forward to ObjectShell
+ mpDocSh->SetModified(bFlag);
+ }
+ }
+ else
+ {
+ // Pass on to base class
+ FmFormModel::SetChanged(bFlag);
+ }
+}
+
+// The model changed, don't call anything else
+void SdDrawDocument::NbcSetChanged(bool bFlag)
+{
+ // forward to baseclass
+ FmFormModel::SetChanged(bFlag);
+}
+
+// NewOrLoadCompleted is called when the document is loaded, or when it is clear
+// it won't load any more.
+void SdDrawDocument::NewOrLoadCompleted(DocCreationMode eMode)
+{
+ if (eMode == DocCreationMode::New)
+ {
+ // New document:
+ // create slideshow and default templates,
+ // create pool for virtual controls
+ CreateLayoutTemplates();
+ CreateDefaultCellStyles();
+
+ static_cast< SdStyleSheetPool* >( mxStyleSheetPool.get() )->CreatePseudosIfNecessary();
+ }
+ else if (eMode == DocCreationMode::Loaded)
+ {
+ // Document has finished loading
+
+ CheckMasterPages();
+
+ if ( GetMasterSdPageCount(PageKind::Standard) > 1 )
+ RemoveUnnecessaryMasterPages( nullptr, true, false );
+
+ for ( sal_uInt16 i = 0; i < GetPageCount(); i++ )
+ {
+ // Check for correct layout names
+ SdPage* pPage = static_cast<SdPage*>( GetPage( i ) );
+
+ if(pPage->TRG_HasMasterPage())
+ {
+ SdPage& rMaster = static_cast<SdPage&>(pPage->TRG_GetMasterPage() );
+
+ if(rMaster.GetLayoutName() != pPage->GetLayoutName())
+ {
+ pPage->SetLayoutName(rMaster.GetLayoutName());
+ }
+ }
+ }
+
+ for ( sal_uInt16 nPage = 0; nPage < GetMasterPageCount(); nPage++)
+ {
+ // LayoutName and PageName must be the same
+ SdPage* pPage = static_cast<SdPage*>( GetMasterPage( nPage ) );
+
+ OUString aName( pPage->GetLayoutName() );
+ aName = aName.copy( 0, aName.indexOf( SD_LT_SEPARATOR ) );
+
+ if( aName != pPage->GetName() )
+ pPage->SetName( aName );
+ }
+
+ // Create names of the styles in the user's language
+ static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->UpdateStdNames();
+
+ // Create any missing styles - eg. formerly, there was no Subtitle style
+ static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->CreatePseudosIfNecessary();
+ }
+
+ // Set default style of Drawing Engine
+ OUString aName( SdResId(STR_STANDARD_STYLESHEET_NAME));
+ SetDefaultStyleSheet(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(aName, SfxStyleFamily::Para)));
+
+ // #i119287# Set default StyleSheet for SdrGrafObj and SdrOle2Obj
+ SetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(SdResId(STR_POOLSHEET_OBJNOLINENOFILL), SfxStyleFamily::Para)));
+
+ // Initialize DrawOutliner and DocumentOutliner, but don't initialize the
+ // global outliner, as it is not document specific like StyleSheetPool and
+ // StyleRequestHandler are.
+ ::Outliner& rDrawOutliner = GetDrawOutliner();
+ rDrawOutliner.SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ EEControlBits nCntrl = rDrawOutliner.GetControlWord();
+ if (mbOnlineSpell)
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+ rDrawOutliner.SetControlWord(nCntrl);
+
+ // Initialize HitTestOutliner and DocumentOutliner, but don't initialize the
+ // global outliner, as it is not document specific like StyleSheetPool and
+ // StyleRequestHandler are.
+ m_pHitTestOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+
+ if(mpOutliner)
+ {
+ mpOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ }
+ if(mpInternalOutliner)
+ {
+ mpInternalOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ }
+
+ if ( eMode == DocCreationMode::Loaded )
+ {
+ // Make presentation objects listeners of the appropriate styles
+ SdStyleSheetPool* pSPool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() );
+ sal_uInt16 nPage, nPageCount;
+
+ // create missing layout style sheets for broken documents
+ // that were created with the 5.2
+ nPageCount = GetMasterSdPageCount( PageKind::Standard );
+ for (nPage = 0; nPage < nPageCount; nPage++)
+ {
+ SdPage* pPage = GetMasterSdPage(nPage, PageKind::Standard);
+ pSPool->CreateLayoutStyleSheets( pPage->GetName(), true );
+ }
+
+ // Default and notes pages:
+ for (nPage = 0; nPage < GetPageCount(); nPage++)
+ {
+ SdPage* pPage = static_cast<SdPage*>(GetPage(nPage));
+ NewOrLoadCompleted( pPage, pSPool );
+ }
+
+ // Master pages:
+ for (nPage = 0; nPage < GetMasterPageCount(); nPage++)
+ {
+ SdPage* pPage = static_cast<SdPage*>(GetMasterPage(nPage));
+
+ NewOrLoadCompleted( pPage, pSPool );
+ }
+ }
+
+ mbNewOrLoadCompleted = true;
+ UpdateAllLinks();
+ SetChanged( false );
+}
+
+/** updates all links, only links in this document should by resolved */
+void SdDrawDocument::UpdateAllLinks()
+{
+ if (s_pDocLockedInsertingLinks || !m_pLinkManager || m_pLinkManager->GetLinks().empty())
+ return;
+
+ s_pDocLockedInsertingLinks = this; // lock inserting links. only links in this document should by resolved
+
+ if (mpDocSh)
+ {
+ comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = mpDocSh->getEmbeddedObjectContainer();
+ rEmbeddedObjectContainer.setUserAllowsLinkUpdate(true);
+ }
+
+ m_pLinkManager->UpdateAllLinks(true, false, nullptr); // query box: update all links?
+
+ if (s_pDocLockedInsertingLinks == this)
+ s_pDocLockedInsertingLinks = nullptr; // unlock inserting links
+}
+
+/** this loops over the presentation objects of a page and repairs some new settings
+ from old binary files and resets all default strings for empty presentation objects.
+*/
+void SdDrawDocument::NewOrLoadCompleted( SdPage* pPage, SdStyleSheetPool* pSPool )
+{
+ sd::ShapeList& rPresentationShapes( pPage->GetPresentationShapeList() );
+ if(rPresentationShapes.isEmpty())
+ return;
+
+ // Create lists of title and outline styles
+ OUString aName = pPage->GetLayoutName();
+ aName = aName.copy( 0, aName.indexOf( SD_LT_SEPARATOR ) );
+
+ std::vector<SfxStyleSheetBase*> aOutlineList;
+ pSPool->CreateOutlineSheetList(aName,aOutlineList);
+
+ SfxStyleSheet* pTitleSheet = static_cast<SfxStyleSheet*>(pSPool->GetTitleSheet(aName));
+
+ SdrObject* pObj = nullptr;
+ rPresentationShapes.seekShape(0);
+
+ // Now look for title and outline text objects, then make those objects
+ // listeners.
+ while( (pObj = rPresentationShapes.getNextShape()) )
+ {
+ if (pObj->GetObjInventor() == SdrInventor::Default)
+ {
+ OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
+ SdrObjKind nId = pObj->GetObjIdentifier();
+
+ if (nId == SdrObjKind::TitleText)
+ {
+ if( pOPO && pOPO->GetOutlinerMode() == OutlinerMode::DontKnow )
+ pOPO->SetOutlinerMode( OutlinerMode::TitleObject );
+
+ // sal_True: don't delete "hard" attributes when doing this.
+ if (pTitleSheet)
+ pObj->SetStyleSheet(pTitleSheet, true);
+ }
+ else if (nId == SdrObjKind::OutlineText)
+ {
+ if( pOPO && pOPO->GetOutlinerMode() == OutlinerMode::DontKnow )
+ pOPO->SetOutlinerMode( OutlinerMode::OutlineObject );
+
+ std::vector<SfxStyleSheetBase*>::iterator iter;
+ for (iter = aOutlineList.begin(); iter != aOutlineList.end(); ++iter)
+ {
+ SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>(*iter);
+
+ if (pSheet)
+ {
+ pObj->StartListening(*pSheet);
+
+ if( iter == aOutlineList.begin())
+ // text frame listens to stylesheet of layer 1
+ pObj->NbcSetStyleSheet(pSheet, true);
+ }
+ }
+ }
+
+ if( auto pTextObj = dynamic_cast<SdrTextObj *>( pObj ) )
+ if (pTextObj->IsEmptyPresObj())
+ {
+ PresObjKind ePresObjKind = pPage->GetPresObjKind(pObj);
+ OUString aString( pPage->GetPresObjText(ePresObjKind) );
+
+ if (!aString.isEmpty())
+ {
+ SdOutliner* pInternalOutl = GetInternalOutliner();
+ pPage->SetObjText( pTextObj, pInternalOutl, ePresObjKind, aString );
+ pObj->NbcSetStyleSheet( pPage->GetStyleSheetForPresObj( ePresObjKind ), true );
+ pInternalOutl->Clear();
+ }
+ }
+ }
+ }
+}
+
+// Local outliner that is used for outline mode. In this outliner, OutlinerViews
+// may be inserted.
+SdOutliner* SdDrawDocument::GetOutliner(bool bCreateOutliner)
+{
+ if (!mpOutliner && bCreateOutliner)
+ {
+ mpOutliner.reset(new SdOutliner( this, OutlinerMode::TextObject ));
+
+ if (mpDocSh)
+ mpOutliner->SetRefDevice( SD_MOD()->GetVirtualRefDevice() );
+
+ mpOutliner->SetDefTab( m_nDefaultTabulator );
+ mpOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ }
+
+ return mpOutliner.get();
+}
+
+// Internal outliner that is used to create text objects. We don't insert any
+// OutlinerViews into this outliner!
+SdOutliner* SdDrawDocument::GetInternalOutliner(bool bCreateOutliner)
+{
+ if ( !mpInternalOutliner && bCreateOutliner )
+ {
+ mpInternalOutliner.reset( new SdOutliner( this, OutlinerMode::TextObject ) );
+
+ // This outliner is only used to create special text objects. As no
+ // information about portions is saved in this outliner, the update mode
+ // can/should always remain sal_False.
+ mpInternalOutliner->SetUpdateLayout( false );
+ mpInternalOutliner->EnableUndo( false );
+
+ if (mpDocSh)
+ mpInternalOutliner->SetRefDevice( SD_MOD()->GetVirtualRefDevice() );
+
+ mpInternalOutliner->SetDefTab( m_nDefaultTabulator );
+ mpInternalOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
+ }
+
+ DBG_ASSERT( !mpInternalOutliner || ( ! mpInternalOutliner->IsUpdateLayout() ) , "InternalOutliner: UpdateMode = sal_True !" );
+ DBG_ASSERT( !mpInternalOutliner || ( ! mpInternalOutliner->IsUndoEnabled() ), "InternalOutliner: Undo = sal_True !" );
+
+ // If you add stuff here, always clear it out.
+ // Advantages:
+ // a) no unnecessary Clear calls
+ // b) no wasted memory
+ DBG_ASSERT( !mpInternalOutliner || ( ( mpInternalOutliner->GetParagraphCount() == 1 ) && ( mpInternalOutliner->GetText( mpInternalOutliner->GetParagraph( 0 ) ).isEmpty() ) ), "InternalOutliner: not empty!" );
+
+ return mpInternalOutliner.get();
+}
+
+// OnlineSpelling on/off
+void SdDrawDocument::SetOnlineSpell(bool bIn)
+{
+ mbOnlineSpell = bIn;
+ EEControlBits nCntrl;
+
+ if(mpOutliner)
+ {
+ nCntrl = mpOutliner->GetControlWord();
+
+ if(mbOnlineSpell)
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+
+ mpOutliner->SetControlWord(nCntrl);
+ }
+
+ if (mpInternalOutliner)
+ {
+ nCntrl = mpInternalOutliner->GetControlWord();
+
+ if (mbOnlineSpell)
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+
+ mpInternalOutliner->SetControlWord(nCntrl);
+ }
+
+ ::Outliner& rOutliner = GetDrawOutliner();
+
+ nCntrl = rOutliner.GetControlWord();
+
+ if (mbOnlineSpell)
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+
+ rOutliner.SetControlWord(nCntrl);
+
+ if (mbOnlineSpell)
+ {
+ StartOnlineSpelling();
+ }
+ else
+ {
+ StopOnlineSpelling();
+ }
+}
+
+// OnlineSpelling: highlighting on/off
+uno::Reference< uno::XInterface > SdDrawDocument::createUnoModel()
+{
+ uno::Reference< uno::XInterface > xModel;
+
+ try
+ {
+ if ( mpDocSh )
+ xModel = mpDocSh->GetModel();
+ }
+ catch( uno::RuntimeException& )
+ {
+ }
+
+ return xModel;
+}
+
+SvxNumType SdDrawDocument::GetPageNumType() const
+{
+ return mePageNumType;
+}
+
+void SdDrawDocument::SetPrinterIndependentLayout (sal_Int32 nMode)
+{
+ switch (nMode)
+ {
+ case css::document::PrinterIndependentLayout::DISABLED:
+ case css::document::PrinterIndependentLayout::ENABLED:
+ // Just store supported modes and inform the doc shell
+ mnPrinterIndependentLayout = nMode;
+
+ // Since it is possible that a SdDrawDocument is constructed without a
+ // SdDrawDocShell the pointer member mpDocSh needs to be tested
+ // before the call is executed. This is e. g. used for copy/paste.
+ if(mpDocSh)
+ {
+ mpDocSh->UpdateRefDevice ();
+ }
+
+ break;
+
+ default:
+ // Ignore unknown values
+ break;
+ }
+}
+
+void SdDrawDocument::SetStartWithPresentation( bool bStartWithPresentation )
+{
+ mbStartWithPresentation = bStartWithPresentation;
+}
+
+void SdDrawDocument::SetExitAfterPresenting( bool bExitAfterPresenting )
+{
+ mbExitAfterPresenting = bExitAfterPresenting;
+}
+
+void SdDrawDocument::PageListChanged()
+{
+ mpDrawPageListWatcher->Invalidate();
+}
+
+void SdDrawDocument::MasterPageListChanged()
+{
+ mpMasterPageListWatcher->Invalidate();
+}
+
+void SdDrawDocument::SetCalcFieldValueHdl(::Outliner* pOutliner)
+{
+ pOutliner->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
+}
+
+sal_uInt16 SdDrawDocument::GetAnnotationAuthorIndex( const OUString& rAuthor )
+{
+ // force current user to have first color
+ if( maAnnotationAuthors.empty() )
+ {
+ SvtUserOptions aUserOptions;
+ maAnnotationAuthors.push_back( aUserOptions.GetFullName() );
+ }
+
+ auto iter = std::find(maAnnotationAuthors.begin(), maAnnotationAuthors.end(), rAuthor);
+ sal_uInt16 idx = static_cast<sal_uInt16>(std::distance(maAnnotationAuthors.begin(), iter));
+
+ if( idx == maAnnotationAuthors.size() )
+ {
+ maAnnotationAuthors.push_back( rAuthor );
+ }
+
+ return idx;
+}
+
+void SdDrawDocument::InitLayoutVector()
+{
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+
+ const Reference<css::uno::XComponentContext> xContext(
+ ::comphelper::getProcessComponentContext() );
+
+ // get file list from configuration
+ const Sequence< OUString > aFiles(
+ officecfg::Office::Impress::Misc::LayoutListFiles::get() );
+
+ if (aFiles.getLength() == 0)
+ return;
+ const Reference<XDocumentBuilder> xDocBuilder = DocumentBuilder::create( xContext );
+
+ for( const auto& rFile : aFiles )
+ {
+ OUString sFilename = comphelper::getExpandedUri(xContext, rFile);
+
+ // load layout file into DOM
+
+ try
+ {
+ // loop over every layout entry in current file
+ const Reference<XDocument> xDoc = xDocBuilder->parseURI( sFilename );
+ const Reference<XNodeList> layoutlist = xDoc->getElementsByTagName("layout");
+ const int nElements = layoutlist->getLength();
+ for(int index=0; index < nElements; index++)
+ maLayoutInfo.push_back( layoutlist->item(index) );
+ }
+ catch (const uno::Exception &)
+ {
+ // skip missing config. files
+ }
+ }
+}
+
+void SdDrawDocument::InitObjectVector()
+{
+ if (utl::ConfigManager::IsFuzzing())
+ return;
+
+ const Reference<css::uno::XComponentContext> xContext(
+ ::comphelper::getProcessComponentContext() );
+
+ // get file list from configuration
+ const Sequence< OUString > aFiles(
+ officecfg::Office::Impress::Misc::PresObjListFiles::get() );
+
+ if (aFiles.getLength() == 0)
+ return;
+ const Reference<XDocumentBuilder> xDocBuilder = DocumentBuilder::create( xContext );
+ for( const auto& rFile : aFiles )
+ {
+ OUString sFilename = comphelper::getExpandedUri(xContext, rFile);
+
+ // load presentation object file into DOM
+
+ try
+ {
+ // loop over every object entry in current file
+ const Reference<XDocument> xDoc = xDocBuilder->parseURI( sFilename );
+ const Reference<XNodeList> objectlist = xDoc->getElementsByTagName("object");
+ const int nElements = objectlist->getLength();
+ for(int index=0; index < nElements; index++)
+ maPresObjectInfo.push_back( objectlist->item(index) );
+ }
+ catch (const uno::Exception &)
+ {
+ // skip missing config. files
+ }
+ }
+}
+
+void SdDrawDocument::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ bool bOwns = false;
+ if (!pWriter)
+ {
+ pWriter = xmlNewTextWriterFilename("model.xml", 0);
+ xmlTextWriterSetIndent(pWriter,1);
+ (void)xmlTextWriterSetIndentString(pWriter, BAD_CAST(" "));
+ (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+ bOwns = true;
+ }
+ (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdDrawDocument"));
+ (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+
+ if (mpOutliner)
+ mpOutliner->dumpAsXml(pWriter);
+ FmFormModel::dumpAsXml(pWriter);
+ if (GetUndoManager())
+ GetUndoManager()->dumpAsXml(pWriter);
+
+ (void)xmlTextWriterEndElement(pWriter);
+ if (bOwns)
+ {
+ (void)xmlTextWriterEndDocument(pWriter);
+ xmlFreeTextWriter(pWriter);
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */