sd/source/core/drawdoc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <libxml/xmlwriter.h>
  21
  22 #include "PageListWatcher.hxx"
  23 #include <com/sun/star/document/PrinterIndependentLayout.hpp>
  24 #include <com/sun/star/i18n/ScriptType.hpp>
  25 #include <com/sun/star/beans/XPropertyContainer.hpp>
  26 #include <com/sun/star/beans/PropertyAttribute.hpp>
  27 #include <com/sun/star/document/XDocumentProperties.hpp>
  28 #include <editeng/forbiddencharacterstable.hxx>
  29
  30 #include <svx/svxids.hrc>
  31 #include <svl/srchitem.hxx>
  32 #include <editeng/eeitem.hxx>
  33 #include <editeng/scriptspaceitem.hxx>
  34
  35 #include <unotools/configmgr.hxx>
  36 #include <unotools/useroptions.hxx>
  37 #include <officecfg/Office/Impress.hxx>
  38
  39 #include <sfx2/printer.hxx>
  40 #include <sfx2/app.hxx>
  41 #include <sfx2/linkmgr.hxx>
  42 #include <svx/dialogs.hrc>
  43 #include <Outliner.hxx>
  44 #include <sdmod.hxx>
  45 #include <editeng/editstat.hxx>
  46 #include <editeng/fontitem.hxx>
  47 #include <svl/flagitem.hxx>
  48 #include <svx/svdoattr.hxx>
  49 #include <svx/svdotext.hxx>
  50 #include <editeng/bulletitem.hxx>
  51 #include <editeng/numitem.hxx>
  52 #include <svx/svditer.hxx>
  53 #include <editeng/unolingu.hxx>
  54 #include <svl/itempool.hxx>
  55 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  56 #include <svx/xtable.hxx>
  57 #include <com/sun/star/linguistic2/XHyphenator.hpp>
  58 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  59 #include <com/sun/star/beans/XPropertySet.hpp>
  60 #include <editeng/outlobj.hxx>
  61 #include <unotools/saveopt.hxx>
  62 #include <comphelper/getexpandeduri.hxx>
  63 #include <i18nlangtag/mslangid.hxx>
  64 #include <i18nlangtag/languagetag.hxx>
  65 #include <unotools/charclass.hxx>
  66 #include <comphelper/processfactory.hxx>
  67 #include <unotools/pathoptions.hxx>
  68 #include <unotools/lingucfg.hxx>
  69 #include <unotools/linguprops.hxx>
  70 #include <com/sun/star/uno/Reference.hxx>
  71 #include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
  72 #include <com/sun/star/xml/dom/XDocument.hpp>
  73 #include <com/sun/star/xml/dom/XNode.hpp>
  74 #include <com/sun/star/xml/dom/XNodeList.hpp>
  75 #include <com/sun/star/xml/dom/DocumentBuilder.hpp>
  76 #include <com/sun/star/uno/XComponentContext.hpp>
  77 #include <rtl/ustring.hxx>
  78 #include <rtl/uri.hxx>
  79
  80 #include <editeng/outliner.hxx>
  81 #include <drawdoc.hxx>
  82 #include <sdpage.hxx>
  83 #include <pglink.hxx>
  84 #include <sdattr.hxx>
  85 #include <strings.hrc>
  86 #include <glob.hxx>
  87 #include <stlpool.hxx>
  88 #include <sdiocmpt.hxx>
  89 #include <sdresid.hxx>
  90 #include <cusshow.hxx>
  91 #include <customshowlist.hxx>
  92 #include <DrawDocShell.hxx>
  93 #include <GraphicDocShell.hxx>
  94 #include <sdxfer.hxx>
  95 #include <ViewShell.hxx>
  96 #include <optsitem.hxx>
  97 #include <FrameView.hxx>
  98 #include <undo/undomanager.hxx>
  99 #include <sdundogr.hxx>
 100 #include <undopage.hxx>
 101 #include <tools/tenccvt.hxx>
 102 #include <vcl/settings.hxx>
 103
 104 using namespace ::sd;
 105 using namespace ::com::sun::star;
 106 using namespace ::com::sun::star::uno;
 107 using namespace ::com::sun::star::lang;
 108 using namespace ::com::sun::star::linguistic2;
 109
 110 using namespace com::sun::star::xml::dom;
 111 using ::com::sun::star::uno::Reference;
 112 using ::com::sun::star::lang::XMultiServiceFactory;
 113
 114
 115 SdDrawDocument* SdDrawDocument::s_pDocLockedInsertingLinks = nullptr;
 116
 117 PresentationSettings::PresentationSettings()
 118 :   mbAll( true ),
 119     mbEndless( false ),
 120     mbCustomShow(false),
 121     mbManual( false ),
 122     mbMouseVisible( false ),
 123     mbMouseAsPen( false ),
 124     mbLockedPages( false ),
 125     mbAlwaysOnTop( false ),
 126     mbFullScreen( true ),
 127     mbAnimationAllowed( true ),
 128     mnPauseTimeout( 10 ),
 129     mbShowPauseLogo( false )
 130 {
 131 }
 132
 133 SdDrawDocument::SdDrawDocument(DocumentType eType, SfxObjectShell* pDrDocSh)
 134 : FmFormModel( !utl::ConfigManager::IsFuzzing() ? SvtPathOptions().GetPalettePath() : OUString(), nullptr, pDrDocSh )
 135 , mpOutliner(nullptr)
 136 , mpInternalOutliner(nullptr)
 137 , mpWorkStartupTimer(nullptr)
 138 , mpOnlineSpellingIdle(nullptr)
 139 , mpOnlineSpellingList(nullptr)
 140 , mpOnlineSearchItem(nullptr)
 141 , mpCustomShowList(nullptr)
 142 , mpDocSh(static_cast< ::sd::DrawDocShell*>(pDrDocSh))
 143 , mpCreatingTransferable( nullptr )
 144 , mbHasOnlineSpellErrors(false)
 145 , mbInitialOnlineSpellingEnabled(true)
 146 , mbNewOrLoadCompleted(false)
 147 , mbOnlineSpell(false)
 148 , mbStartWithPresentation( false )
 149 , mbExitAfterPresenting( false )
 150 , meLanguage( LANGUAGE_SYSTEM )
 151 , meLanguageCJK( LANGUAGE_SYSTEM )
 152 , meLanguageCTL( LANGUAGE_SYSTEM )
 153 , mePageNumType(SVX_NUM_ARABIC)
 154 , mbAllocDocSh(false)
 155 , meDocType(eType)
 156 , mpCharClass(nullptr)
 157 , mbUseEmbedFonts(false)
 158 {
 159     mpDrawPageListWatcher.reset(new ImpDrawPageListWatcher(*this));
 160     mpMasterPageListWatcher.reset(new ImpMasterPageListWatcher(*this));
 161
 162     InitLayoutVector();
 163     InitObjectVector();
 164     SetObjectShell(pDrDocSh);       // for VCDrawModel
 165
 166     if (mpDocSh)
 167     {
 168         SetSwapGraphics();
 169     }
 170
 171     // Set measuring unit (of the application) and scale (of SdMod)
 172     sal_Int32 nX, nY;
 173     SdOptions* pOptions = SD_MOD()->GetSdOptions(meDocType);
 174     pOptions->GetScale( nX, nY );
 175
 176     // Allow UI scale only for draw documents.
 177     if( eType == DocumentType::Draw )
 178         SetUIUnit( static_cast<FieldUnit>(pOptions->GetMetric()), Fraction( nX, nY ) );  // user-defined
 179     else
 180         SetUIUnit( static_cast<FieldUnit>(pOptions->GetMetric()), Fraction( 1, 1 ) );    // default
 181
 182     SetScaleUnit(MapUnit::Map100thMM);
 183     SetScaleFraction(Fraction(1, 1));
 184     SetDefaultFontHeight(847);     // 24p
 185
 186     pItemPool->SetDefaultMetric(MapUnit::Map100thMM);
 187     pItemPool->FreezeIdRanges();
 188     SetTextDefaults();
 189
 190     // DrawingEngine has to know where it is...
 191     FmFormModel::SetStyleSheetPool( new SdStyleSheetPool( GetPool(), this ) );
 192
 193     // Set StyleSheetPool for DrawOutliner, so text objects can be read correctly.
 194     // The link to the StyleRequest handler of the document is set later, in
 195     // NewOrLoadCompleted, because only then do all the templates exist.
 196     SdrOutliner& rOutliner = GetDrawOutliner();
 197     rOutliner.SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 198     SetCalcFieldValueHdl( &rOutliner );
 199
 200     // set linguistic options
 201     if (!utl::ConfigManager::IsFuzzing())
 202     {
 203         const SvtLinguConfig    aLinguConfig;
 204         SvtLinguOptions         aOptions;
 205         aLinguConfig.GetOptions( aOptions );
 206
 207         SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage,
 208             css::i18n::ScriptType::LATIN), EE_CHAR_LANGUAGE );
 209         SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CJK,
 210             css::i18n::ScriptType::ASIAN), EE_CHAR_LANGUAGE_CJK );
 211         SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CTL,
 212             css::i18n::ScriptType::COMPLEX), EE_CHAR_LANGUAGE_CTL );
 213
 214         mbOnlineSpell = aOptions.bIsSpellAuto;
 215     }
 216
 217     LanguageType eRealLanguage = MsLangId::getRealLanguage( meLanguage );
 218     LanguageTag aLanguageTag( eRealLanguage);
 219     mpCharClass.reset(new CharClass( aLanguageTag ));
 220
 221     // If the current application language is a language that uses right-to-left text...
 222     LanguageType eRealCTLLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
 223
 224     // for korean and japanese languages we have a different default for apply spacing between asian, latin and ctl text
 225     if (MsLangId::isKorean(eRealCTLLanguage) || (LANGUAGE_JAPANESE == eRealCTLLanguage))
 226     {
 227         GetPool().GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
 228     }
 229
 230     // Set DefTab and SpellOptions for the SD module
 231     sal_uInt16 nDefTab = pOptions->GetDefTab();
 232     SetDefaultTabulator( nDefTab );
 233
 234     try
 235     {
 236         Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
 237         if ( xSpellChecker.is() )
 238             rOutliner.SetSpeller( xSpellChecker );
 239
 240         Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
 241         if( xHyphenator.is() )
 242             rOutliner.SetHyphenator( xHyphenator );
 243
 244         SetForbiddenCharsTable(SvxForbiddenCharactersTable::makeForbiddenCharactersTable(::comphelper::getProcessComponentContext()));
 245     }
 246     catch(...)
 247     {
 248         OSL_FAIL("Can't get SpellChecker");
 249     }
 250
 251     rOutliner.SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
 252
 253     if (mpDocSh)
 254     {
 255         SetLinkManager( new sfx2::LinkManager(mpDocSh) );
 256     }
 257
 258     EEControlBits nCntrl = rOutliner.GetControlWord();
 259     nCntrl |= EEControlBits::ALLOWBIGOBJS;
 260
 261     if (mbOnlineSpell)
 262         nCntrl |= EEControlBits::ONLINESPELLING;
 263     else
 264         nCntrl &= ~EEControlBits::ONLINESPELLING;
 265
 266     nCntrl &= ~ EEControlBits::ULSPACESUMMATION;
 267     if ( meDocType != DocumentType::Impress )
 268         SetSummationOfParagraphs( false );
 269     else
 270     {
 271         SetSummationOfParagraphs( pOptions->IsSummationOfParagraphs() );
 272         if ( pOptions->IsSummationOfParagraphs() )
 273             nCntrl |= EEControlBits::ULSPACESUMMATION;
 274     }
 275     rOutliner.SetControlWord(nCntrl);
 276
 277     // Initialize the printer independent layout mode
 278     SetPrinterIndependentLayout (pOptions->GetPrinterIndependentLayout());
 279
 280     // Set the StyleSheetPool for HitTestOutliner.
 281     // The link to the StyleRequest handler of the document is set later, in
 282     // NewOrLoadCompleted, because only then do all the templates exist.
 283     pHitTestOutliner->SetStyleSheetPool( static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()) );
 284
 285     SetCalcFieldValueHdl( pHitTestOutliner.get() );
 286
 287     try
 288     {
 289         Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
 290         if ( xSpellChecker.is() )
 291             pHitTestOutliner->SetSpeller( xSpellChecker );
 292
 293         Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
 294         if( xHyphenator.is() )
 295             pHitTestOutliner->SetHyphenator( xHyphenator );
 296     }
 297     catch(...)
 298     {
 299         OSL_FAIL("Can't get SpellChecker");
 300     }
 301
 302     pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
 303
 304     EEControlBits nCntrl2 = pHitTestOutliner->GetControlWord();
 305     nCntrl2 |= EEControlBits::ALLOWBIGOBJS;
 306     nCntrl2 &= ~EEControlBits::ONLINESPELLING;
 307
 308     nCntrl2 &= ~ EEControlBits::ULSPACESUMMATION;
 309     if ( pOptions->IsSummationOfParagraphs() )
 310         nCntrl2 |= EEControlBits::ULSPACESUMMATION;
 311
 312     pHitTestOutliner->SetControlWord( nCntrl2 );
 313
 314     /** Create layers
 315       *
 316       * We create the following default layers on all pages and master pages:
 317       *
 318       * STR_LAYOUT    : default layer for drawing objects
 319       *
 320       * STR_BCKGRND   : background of the master page
 321       *                 (currently unused within normal pages)
 322       *
 323       * STR_BCKGRNDOBJ: objects on the background of master pages
 324       *                 (currently unused within normal pages)
 325       *
 326       * STR_CONTROLS  : default layer for controls
 327       */
 328
 329     {
 330         OUString aControlLayerName( SdResId(STR_LAYER_CONTROLS) );
 331
 332         SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
 333         rLayerAdmin.NewLayer( SdResId(STR_LAYER_LAYOUT) );
 334         rLayerAdmin.NewLayer( SdResId(STR_LAYER_BCKGRND) );
 335         rLayerAdmin.NewLayer( SdResId(STR_LAYER_BCKGRNDOBJ) );
 336         rLayerAdmin.NewLayer( aControlLayerName );
 337         rLayerAdmin.NewLayer( SdResId(STR_LAYER_MEASURELINES) );
 338
 339         rLayerAdmin.SetControlLayerName(aControlLayerName);
 340     }
 341
 342 }
 343
 344 // Destructor
 345 SdDrawDocument::~SdDrawDocument()
 346 {
 347     Broadcast(SdrHint(SdrHintKind::ModelCleared));
 348
 349     if (mpWorkStartupTimer)
 350     {
 351         if ( mpWorkStartupTimer->IsActive() )
 352             mpWorkStartupTimer->Stop();
 353
 354         mpWorkStartupTimer.reset();
 355     }
 356
 357     StopOnlineSpelling();
 358     mpOnlineSearchItem.reset();
 359
 360     CloseBookmarkDoc();
 361     SetAllocDocSh(false);
 362
 363     ClearModel(true);
 364
 365     if (pLinkManager)
 366     {
 367         // Release BaseLinks
 368         if ( !pLinkManager->GetLinks().empty() )
 369         {
 370             pLinkManager->Remove( 0, pLinkManager->GetLinks().size() );
 371         }
 372
 373         delete pLinkManager;
 374         pLinkManager = nullptr;
 375     }
 376
 377     maFrameViewList.clear();
 378
 379     if (mpCustomShowList)
 380     {
 381         for (sal_uLong j = 0; j < mpCustomShowList->size(); j++)
 382         {
 383             // If necessary, delete CustomShows
 384             SdCustomShow* pCustomShow = (*mpCustomShowList)[j];
 385             delete pCustomShow;
 386         }
 387
 388         mpCustomShowList.reset();
 389     }
 390
 391     mpOutliner.reset();
 392     mpInternalOutliner.reset();
 393     mpCharClass.reset();
 394 }
 395
 396 void SdDrawDocument::adaptSizeAndBorderForAllPages(
 397     const Size& rNewSize,
 398     long nLeft,
 399     long nRight,
 400     long nUpper,
 401     long nLower)
 402 {
 403     const sal_uInt16 nMasterPageCnt(GetMasterSdPageCount(PageKind::Standard));
 404     const sal_uInt16 nPageCnt(GetSdPageCount(PageKind::Standard));
 405
 406     if(0 == nMasterPageCnt && 0 == nPageCnt)
 407     {
 408         return;
 409     }
 410
 411     SdPage* pPage(0 != nPageCnt ? GetSdPage(0, PageKind::Standard) : GetMasterSdPage(0, PageKind::Standard));
 412
 413     // call fully implemented local version, including getting
 414     // some more information from one of the Pages (1st one)
 415     AdaptPageSizeForAllPages(
 416         rNewSize,
 417         PageKind::Standard,
 418         nullptr,
 419         nLeft,
 420         nRight,
 421         nUpper,
 422         nLower,
 423         true,
 424         pPage->GetOrientation(),
 425         pPage->GetPaperBin(),
 426         pPage->IsBackgroundFullSize());
 427
 428     // adjust handout page to new format of the standard page
 429     if(0 != nPageCnt)
 430     {
 431         GetSdPage(0, PageKind::Handout)->CreateTitleAndLayout(true);
 432     }
 433 }
 434
 435 void SdDrawDocument::AdaptPageSizeForAllPages(
 436     const Size& rNewSize,
 437     PageKind ePageKind,
 438     SdUndoGroup* pUndoGroup,
 439     long nLeft,
 440     long nRight,
 441     long nUpper,
 442     long nLower,
 443     bool bScaleAll,
 444     Orientation eOrientation,
 445     sal_uInt16 nPaperBin,
 446     bool bBackgroundFullSize)
 447 {
 448     sal_uInt16 i;
 449     const sal_uInt16 nMasterPageCnt(GetMasterSdPageCount(ePageKind));
 450     const sal_uInt16 nPageCnt(GetSdPageCount(ePageKind));
 451
 452     if(0 == nMasterPageCnt && 0 == nPageCnt)
 453     {
 454         return;
 455     }
 456
 457     for (i = 0; i < nMasterPageCnt; i++)
 458     {
 459         // first, handle all master pages
 460         SdPage* pPage(GetMasterSdPage(i, ePageKind));
 461
 462         if(pUndoGroup)
 463         {
 464             SdUndoAction* pUndo(
 465                 new SdPageFormatUndoAction(
 466                     this,
 467                     pPage,
 468                     pPage->GetSize(),
 469                     pPage->GetLeftBorder(), pPage->GetRightBorder(),
 470                     pPage->GetUpperBorder(), pPage->GetLowerBorder(),
 471                     pPage->GetOrientation(),
 472                     pPage->GetPaperBin(),
 473                     pPage->IsBackgroundFullSize(),
 474                     rNewSize,
 475                     nLeft, nRight,
 476                     nUpper, nLower,
 477                     bScaleAll,
 478                     eOrientation,
 479                     nPaperBin,
 480                     bBackgroundFullSize));
 481             pUndoGroup->AddAction(pUndo);
 482         }
 483
 484         if (rNewSize.Width() > 0 || nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
 485         {
 486             ::tools::Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
 487             pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
 488
 489             if (rNewSize.Width() > 0)
 490             {
 491                 pPage->SetSize(rNewSize);
 492             }
 493         }
 494
 495         if( nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
 496         {
 497             pPage->SetBorder(nLeft, nUpper, nRight, nLower);
 498         }
 499
 500         pPage->SetOrientation(eOrientation);
 501         pPage->SetPaperBin( nPaperBin );
 502         pPage->SetBackgroundFullSize( bBackgroundFullSize );
 503
 504         if ( ePageKind == PageKind::Standard )
 505         {
 506             GetMasterSdPage(i, PageKind::Notes)->CreateTitleAndLayout();
 507         }
 508
 509         pPage->CreateTitleAndLayout();
 510     }
 511
 512     for (i = 0; i < nPageCnt; i++)
 513     {
 514         // then, handle all pages
 515         SdPage* pPage(GetSdPage(i, ePageKind));
 516
 517         if(pUndoGroup)
 518         {
 519             SdUndoAction* pUndo(
 520                 new SdPageFormatUndoAction(
 521                     this,
 522                     pPage,
 523                     pPage->GetSize(),
 524                     pPage->GetLeftBorder(), pPage->GetRightBorder(),
 525                     pPage->GetUpperBorder(), pPage->GetLowerBorder(),
 526                     pPage->GetOrientation(),
 527                     pPage->GetPaperBin(),
 528                     pPage->IsBackgroundFullSize(),
 529                     rNewSize,
 530                     nLeft, nRight,
 531                     nUpper, nLower,
 532                     bScaleAll,
 533                     eOrientation,
 534                     nPaperBin,
 535                     bBackgroundFullSize));
 536             pUndoGroup->AddAction(pUndo);
 537         }
 538
 539         if (rNewSize.Width() > 0 || nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
 540         {
 541             ::tools::Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
 542             pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
 543
 544             if (rNewSize.Width() > 0)
 545             {
 546                 pPage->SetSize(rNewSize);
 547             }
 548         }
 549
 550         if( nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
 551         {
 552             pPage->SetBorder(nLeft, nUpper, nRight, nLower);
 553         }
 554
 555         pPage->SetOrientation(eOrientation);
 556         pPage->SetPaperBin( nPaperBin );
 557         pPage->SetBackgroundFullSize( bBackgroundFullSize );
 558
 559         if ( ePageKind == PageKind::Standard )
 560         {
 561             SdPage* pNotesPage = GetSdPage(i, PageKind::Notes);
 562             pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
 563         }
 564
 565         pPage->SetAutoLayout( pPage->GetAutoLayout() );
 566     }
 567 }
 568
 569 SdrModel* SdDrawDocument::AllocModel() const
 570 {
 571     return AllocSdDrawDocument();
 572 }
 573
 574 namespace
 575 {
 576
 577 /// Copies all user-defined properties from pSource to pDestination.
 578 void lcl_copyUserDefinedProperties(SfxObjectShell* pSource, SfxObjectShell* pDestination)
 579 {
 580     if (!pSource || !pDestination)
 581         return;
 582
 583     uno::Reference<document::XDocumentProperties> xSource = pSource->getDocProperties();
 584     uno::Reference<document::XDocumentProperties> xDestination = pDestination->getDocProperties();
 585     uno::Reference<beans::XPropertyContainer> xSourcePropertyContainer = xSource->getUserDefinedProperties();
 586     uno::Reference<beans::XPropertyContainer> xDestinationPropertyContainer = xDestination->getUserDefinedProperties();
 587     uno::Reference<beans::XPropertySet> xSourcePropertySet(xSourcePropertyContainer, uno::UNO_QUERY);
 588     uno::Sequence<beans::Property> aProperties = xSourcePropertySet->getPropertySetInfo()->getProperties();
 589
 590     for (const beans::Property& rProperty : aProperties)
 591     {
 592         const OUString& rKey = rProperty.Name;
 593         uno::Any aValue = xSourcePropertySet->getPropertyValue(rKey);
 594         // We know that pDestination was just created, so has no properties: addProperty() will never throw.
 595         xDestinationPropertyContainer->addProperty(rKey, beans::PropertyAttribute::REMOVABLE, aValue);
 596     }
 597 }
 598
 599 }
 600
 601 // This method creates a new document (SdDrawDocument) and returns a pointer to
 602 // said document. The drawing engine uses this method to put the document (or
 603 // parts of it) into the clipboard/DragServer.
 604 SdDrawDocument* SdDrawDocument::AllocSdDrawDocument() const
 605 {
 606     SdDrawDocument* pNewModel = nullptr;
 607
 608     if( mpCreatingTransferable )
 609     {
 610         // Document is created for drag & drop/clipboard. To be able to
 611         // do this, the document has to know a DocShell (SvPersist).
 612         SfxObjectShell*   pObj = nullptr;
 613         ::sd::DrawDocShell*     pNewDocSh = nullptr;
 614
 615         if( meDocType == DocumentType::Impress )
 616             mpCreatingTransferable->SetDocShell( new ::sd::DrawDocShell(
 617                 SfxObjectCreateMode::EMBEDDED, true, meDocType ) );
 618         else
 619             mpCreatingTransferable->SetDocShell( new ::sd::GraphicDocShell(
 620                 SfxObjectCreateMode::EMBEDDED, true, meDocType ) );
 621
 622         pNewDocSh = static_cast< ::sd::DrawDocShell*>( pObj = mpCreatingTransferable->GetDocShell().get() );
 623         pNewDocSh->DoInitNew();
 624         pNewModel = pNewDocSh->GetDoc();
 625
 626         // Only necessary for clipboard -
 627         // for drag & drop this is handled by DragServer
 628         SdStyleSheetPool* pOldStylePool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() );
 629         SdStyleSheetPool* pNewStylePool = static_cast<SdStyleSheetPool*>( pNewModel->GetStyleSheetPool() );
 630
 631         pNewStylePool->CopyGraphicSheets(*pOldStylePool);
 632         pNewStylePool->CopyCellSheets(*pOldStylePool);
 633         pNewStylePool->CopyTableStyles(*pOldStylePool);
 634
 635         for (sal_uInt16 i = 0; i < GetMasterSdPageCount(PageKind::Standard); i++)
 636         {
 637             // Move with all of the master page's layouts
 638             OUString aOldLayoutName(const_cast<SdDrawDocument*>(this)->GetMasterSdPage(i, PageKind::Standard)->GetLayoutName());
 639             aOldLayoutName = aOldLayoutName.copy( 0, aOldLayoutName.indexOf( SD_LT_SEPARATOR ) );
 640             SdStyleSheetVector aCreatedSheets;
 641             pNewStylePool->CopyLayoutSheets(aOldLayoutName, *pOldStylePool, aCreatedSheets );
 642         }
 643
 644         lcl_copyUserDefinedProperties(GetDocSh(), pNewDocSh);
 645
 646         pNewModel->NewOrLoadCompleted( DOC_LOADED );  // loaded from source document
 647     }
 648     else if( mbAllocDocSh )
 649     {
 650         // Create a DocShell which is then returned with GetAllocedDocSh()
 651         SdDrawDocument* pDoc = const_cast<SdDrawDocument*>(this);
 652         pDoc->SetAllocDocSh(false);
 653         pDoc->mxAllocedDocShRef = new ::sd::DrawDocShell(
 654             SfxObjectCreateMode::EMBEDDED, true, meDocType);
 655         pDoc->mxAllocedDocShRef->DoInitNew();
 656         pNewModel = pDoc->mxAllocedDocShRef->GetDoc();
 657     }
 658     else
 659     {
 660         pNewModel = new SdDrawDocument(meDocType, nullptr);
 661     }
 662
 663     return pNewModel;
 664 }
 665
 666 SdPage* SdDrawDocument::AllocSdPage(bool bMasterPage)
 667 {
 668     return new SdPage(*this, bMasterPage);
 669 }
 670
 671 // This method creates a new page (SdPage) and returns a pointer to said page.
 672 // The drawing engine uses this method to create pages (whose types it does
 673 // not know, as they are _derivatives_ of SdrPage) when loading.
 674 SdrPage* SdDrawDocument::AllocPage(bool bMasterPage)
 675 {
 676     return AllocSdPage(bMasterPage);
 677 }
 678
 679 // When the model has changed
 680 void SdDrawDocument::SetChanged(bool bFlag)
 681 {
 682     if (mpDocSh)
 683     {
 684         if (mbNewOrLoadCompleted && mpDocSh->IsEnableSetModified())
 685         {
 686             // Pass on to base class
 687             FmFormModel::SetChanged(bFlag);
 688
 689             // Forward to ObjectShell
 690             mpDocSh->SetModified(bFlag);
 691         }
 692     }
 693     else
 694     {
 695         // Pass on to base class
 696         FmFormModel::SetChanged(bFlag);
 697     }
 698 }
 699
 700 // The model changed, don't call anything else
 701 void SdDrawDocument::NbcSetChanged(bool bFlag)
 702 {
 703     // forward to baseclass
 704     FmFormModel::SetChanged(bFlag);
 705 }
 706
 707 // NewOrLoadCompleted is called when the document is loaded, or when it is clear
 708 // it won't load any more.
 709 void SdDrawDocument::NewOrLoadCompleted(DocCreationMode eMode)
 710 {
 711     if (eMode == NEW_DOC)
 712     {
 713         // New document:
 714         // create slideshow and default templates,
 715         // create pool for virtual controls
 716         CreateLayoutTemplates();
 717         CreateDefaultCellStyles();
 718
 719         static_cast< SdStyleSheetPool* >( mxStyleSheetPool.get() )->CreatePseudosIfNecessary();
 720     }
 721     else if (eMode == DOC_LOADED)
 722     {
 723             // Document has finished loading
 724
 725         CheckMasterPages();
 726
 727         if ( GetMasterSdPageCount(PageKind::Standard) > 1 )
 728             RemoveUnnecessaryMasterPages( nullptr, true, false );
 729
 730         for ( sal_uInt16 i = 0; i < GetPageCount(); i++ )
 731         {
 732             // Check for correct layout names
 733             SdPage* pPage = static_cast<SdPage*>( GetPage( i ) );
 734
 735             if(pPage->TRG_HasMasterPage())
 736             {
 737                 SdPage& rMaster = static_cast<SdPage&>(pPage->TRG_GetMasterPage() );
 738
 739                 if(rMaster.GetLayoutName() != pPage->GetLayoutName())
 740                 {
 741                     pPage->SetLayoutName(rMaster.GetLayoutName());
 742                 }
 743             }
 744         }
 745
 746         for ( sal_uInt16 nPage = 0; nPage < GetMasterPageCount(); nPage++)
 747         {
 748             // LayoutName and PageName must be the same
 749             SdPage* pPage = static_cast<SdPage*>( GetMasterPage( nPage ) );
 750
 751             OUString aName( pPage->GetLayoutName() );
 752             aName = aName.copy( 0, aName.indexOf( SD_LT_SEPARATOR ) );
 753
 754             if( aName != pPage->GetName() )
 755                 pPage->SetName( aName );
 756         }
 757
 758         // Create names of the default layers in the user's language
 759         RestoreLayerNames();
 760
 761         // Create names of the styles in the user's language
 762         static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->UpdateStdNames();
 763
 764         // Create any missing styles - eg. formerly, there was no Subtitle style
 765         static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->CreatePseudosIfNecessary();
 766     }
 767
 768     // Set default style of Drawing Engine
 769     OUString aName( SdResId(STR_STANDARD_STYLESHEET_NAME));
 770     SetDefaultStyleSheet(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(aName, SfxStyleFamily::Para)));
 771
 772     // #i119287# Set default StyleSheet for SdrGrafObj and SdrOle2Obj
 773     SetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(SdResId(STR_POOLSHEET_OBJNOLINENOFILL), SfxStyleFamily::Para)));
 774
 775     // Initialize DrawOutliner and DocumentOutliner, but don't initialize the
 776     // global outliner, as it is not document specific like StyleSheetPool and
 777     // StyleRequestHandler are.
 778     ::Outliner& rDrawOutliner = GetDrawOutliner();
 779     rDrawOutliner.SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 780     EEControlBits nCntrl = rDrawOutliner.GetControlWord();
 781     if (mbOnlineSpell)
 782         nCntrl |= EEControlBits::ONLINESPELLING;
 783     else
 784         nCntrl &= ~EEControlBits::ONLINESPELLING;
 785     rDrawOutliner.SetControlWord(nCntrl);
 786
 787     // Initialize HitTestOutliner and DocumentOutliner, but don't initialize the
 788     // global outliner, as it is not document specific like StyleSheetPool and
 789     // StyleRequestHandler are.
 790     pHitTestOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 791
 792     if(mpOutliner)
 793     {
 794         mpOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 795     }
 796     if(mpInternalOutliner)
 797     {
 798         mpInternalOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 799     }
 800
 801     if ( eMode == DOC_LOADED )
 802     {
 803         // Make presentation objects listeners of the appropriate styles
 804         SdStyleSheetPool* pSPool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() );
 805         sal_uInt16 nPage, nPageCount;
 806
 807         // create missing layout style sheets for broken documents
 808         //         that where created with the 5.2
 809         nPageCount = GetMasterSdPageCount( PageKind::Standard );
 810         for (nPage = 0; nPage < nPageCount; nPage++)
 811         {
 812             SdPage* pPage = GetMasterSdPage(nPage, PageKind::Standard);
 813             pSPool->CreateLayoutStyleSheets( pPage->GetName(), true );
 814         }
 815
 816         // Default and notes pages:
 817         for (nPage = 0; nPage < GetPageCount(); nPage++)
 818         {
 819             SdPage* pPage = static_cast<SdPage*>(GetPage(nPage));
 820             NewOrLoadCompleted( pPage, pSPool );
 821         }
 822
 823         // Master pages:
 824         for (nPage = 0; nPage < GetMasterPageCount(); nPage++)
 825         {
 826             SdPage* pPage = static_cast<SdPage*>(GetMasterPage(nPage));
 827
 828             NewOrLoadCompleted( pPage, pSPool );
 829         }
 830     }
 831
 832     mbNewOrLoadCompleted = true;
 833     UpdateAllLinks();
 834     SetChanged( false );
 835 }
 836
 837 /** updates all links, only links in this document should by resolved */
 838 void SdDrawDocument::UpdateAllLinks()
 839 {
 840     if (!s_pDocLockedInsertingLinks && pLinkManager && !pLinkManager->GetLinks().empty())
 841     {
 842         s_pDocLockedInsertingLinks = this; // lock inserting links. only links in this document should by resolved
 843
 844         if (mpDocSh)
 845         {
 846             comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = mpDocSh->getEmbeddedObjectContainer();
 847             rEmbeddedObjectContainer.setUserAllowsLinkUpdate(true);
 848         }
 849
 850         pLinkManager->UpdateAllLinks(true, false, nullptr);  // query box: update all links?
 851
 852         if (s_pDocLockedInsertingLinks == this)
 853             s_pDocLockedInsertingLinks = nullptr;  // unlock inserting links
 854     }
 855 }
 856
 857 /** this loops over the presentation objects of a page and repairs some new settings
 858     from old binary files and resets all default strings for empty presentation objects.
 859 */
 860 void SdDrawDocument::NewOrLoadCompleted( SdPage* pPage, SdStyleSheetPool* pSPool )
 861 {
 862     sd::ShapeList& rPresentationShapes( pPage->GetPresentationShapeList() );
 863     if(!rPresentationShapes.isEmpty())
 864     {
 865         // Create lists of title and outline styles
 866         OUString aName = pPage->GetLayoutName();
 867         aName = aName.copy( 0, aName.indexOf( SD_LT_SEPARATOR ) );
 868
 869         std::vector<SfxStyleSheetBase*> aOutlineList;
 870         pSPool->CreateOutlineSheetList(aName,aOutlineList);
 871
 872         SfxStyleSheet* pTitleSheet = static_cast<SfxStyleSheet*>(pSPool->GetTitleSheet(aName));
 873
 874         SdrObject* pObj = nullptr;
 875         rPresentationShapes.seekShape(0);
 876
 877         // Now look for title and outline text objects, then make those objects
 878         // listeners.
 879         while( (pObj = rPresentationShapes.getNextShape()) )
 880         {
 881             if (pObj->GetObjInventor() == SdrInventor::Default)
 882             {
 883                 OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
 884                 sal_uInt16 nId = pObj->GetObjIdentifier();
 885
 886                 if (nId == OBJ_TITLETEXT)
 887                 {
 888                     if( pOPO && pOPO->GetOutlinerMode() == OutlinerMode::DontKnow )
 889                         pOPO->SetOutlinerMode( OutlinerMode::TitleObject );
 890
 891                     // sal_True: don't delete "hard" attributes when doing this.
 892                     if (pTitleSheet)
 893                         pObj->SetStyleSheet(pTitleSheet, true);
 894                 }
 895                 else if (nId == OBJ_OUTLINETEXT)
 896                 {
 897                     if( pOPO && pOPO->GetOutlinerMode() == OutlinerMode::DontKnow )
 898                         pOPO->SetOutlinerMode( OutlinerMode::OutlineObject );
 899
 900                     std::vector<SfxStyleSheetBase*>::iterator iter;
 901                     for (iter = aOutlineList.begin(); iter != aOutlineList.end(); ++iter)
 902                     {
 903                         SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>(*iter);
 904
 905                         if (pSheet)
 906                         {
 907                             pObj->StartListening(*pSheet);
 908
 909                             if( iter == aOutlineList.begin())
 910                                 // text frame listens to stylesheet of layer 1
 911                                 pObj->NbcSetStyleSheet(pSheet, true);
 912                         }
 913                     }
 914                 }
 915
 916                 if( dynamic_cast< const SdrTextObj *>( pObj ) !=  nullptr && pObj->IsEmptyPresObj())
 917                 {
 918                     PresObjKind ePresObjKind = pPage->GetPresObjKind(pObj);
 919                     OUString aString( pPage->GetPresObjText(ePresObjKind) );
 920
 921                     if (!aString.isEmpty())
 922                     {
 923                         SdOutliner* pInternalOutl = GetInternalOutliner();
 924                         pPage->SetObjText( static_cast<SdrTextObj*>(pObj), pInternalOutl, ePresObjKind, aString );
 925                         pObj->NbcSetStyleSheet( pPage->GetStyleSheetForPresObj( ePresObjKind ), true );
 926                         pInternalOutl->Clear();
 927                     }
 928                 }
 929             }
 930         }
 931     }
 932 }
 933
 934 // Local outliner that is used for outline mode. In this outliner, OutlinerViews
 935 // may be inserted.
 936 SdOutliner* SdDrawDocument::GetOutliner(bool bCreateOutliner)
 937 {
 938     if (!mpOutliner && bCreateOutliner)
 939     {
 940         mpOutliner.reset(new SdOutliner( this, OutlinerMode::TextObject ));
 941
 942         if (mpDocSh)
 943             mpOutliner->SetRefDevice( SD_MOD()->GetVirtualRefDevice() );
 944
 945         mpOutliner->SetDefTab( nDefaultTabulator );
 946         mpOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 947     }
 948
 949     return mpOutliner.get();
 950 }
 951
 952 // Internal outliner that is used to create text objects. We don't insert any
 953 // OutlinerViews into this outliner!
 954 SdOutliner* SdDrawDocument::GetInternalOutliner(bool bCreateOutliner)
 955 {
 956     if ( !mpInternalOutliner && bCreateOutliner )
 957     {
 958         mpInternalOutliner.reset( new SdOutliner( this, OutlinerMode::TextObject ) );
 959
 960         // This outliner is only used to create special text objects. As no
 961         // information about portions is saved in this outliner, the update mode
 962         // can/should always remain sal_False.
 963         mpInternalOutliner->SetUpdateMode( false );
 964         mpInternalOutliner->EnableUndo( false );
 965
 966         if (mpDocSh)
 967             mpInternalOutliner->SetRefDevice( SD_MOD()->GetVirtualRefDevice() );
 968
 969         mpInternalOutliner->SetDefTab( nDefaultTabulator );
 970         mpInternalOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(GetStyleSheetPool()));
 971     }
 972
 973     DBG_ASSERT( !mpInternalOutliner || ( ! mpInternalOutliner->GetUpdateMode() ) , "InternalOutliner: UpdateMode = sal_True !" );
 974     DBG_ASSERT( !mpInternalOutliner || ( ! mpInternalOutliner->IsUndoEnabled() ), "InternalOutliner: Undo = sal_True !" );
 975
 976     // If you add stuff here, always clear it out.
 977     // Advantages:
 978     // a) no unnecessary Clear calls
 979     // b) no wasted memory
 980     DBG_ASSERT( !mpInternalOutliner || ( ( mpInternalOutliner->GetParagraphCount() == 1 ) && ( mpInternalOutliner->GetText( mpInternalOutliner->GetParagraph( 0 ) ).isEmpty() ) ), "InternalOutliner: not empty!" );
 981
 982     return mpInternalOutliner.get();
 983 }
 984
 985 // OnlineSpelling on/off
 986 void SdDrawDocument::SetOnlineSpell(bool bIn)
 987 {
 988     mbOnlineSpell = bIn;
 989     EEControlBits nCntrl;
 990
 991     if(mpOutliner)
 992     {
 993         nCntrl = mpOutliner->GetControlWord();
 994
 995         if(mbOnlineSpell)
 996             nCntrl |= EEControlBits::ONLINESPELLING;
 997         else
 998             nCntrl &= ~EEControlBits::ONLINESPELLING;
 999
1000         mpOutliner->SetControlWord(nCntrl);
1001     }
1002
1003     if (mpInternalOutliner)
1004     {
1005         nCntrl = mpInternalOutliner->GetControlWord();
1006
1007         if (mbOnlineSpell)
1008             nCntrl |= EEControlBits::ONLINESPELLING;
1009         else
1010             nCntrl &= ~EEControlBits::ONLINESPELLING;
1011
1012         mpInternalOutliner->SetControlWord(nCntrl);
1013     }
1014
1015     ::Outliner& rOutliner = GetDrawOutliner();
1016
1017     nCntrl = rOutliner.GetControlWord();
1018
1019     if (mbOnlineSpell)
1020         nCntrl |= EEControlBits::ONLINESPELLING;
1021     else
1022         nCntrl &= ~EEControlBits::ONLINESPELLING;
1023
1024     rOutliner.SetControlWord(nCntrl);
1025
1026     if (mbOnlineSpell)
1027     {
1028         StartOnlineSpelling();
1029     }
1030     else
1031     {
1032         StopOnlineSpelling();
1033     }
1034 }
1035
1036 // OnlineSpelling: highlighting on/off
1037 uno::Reference< uno::XInterface > SdDrawDocument::createUnoModel()
1038 {
1039     uno::Reference< uno::XInterface > xModel;
1040
1041     try
1042     {
1043         if ( mpDocSh )
1044             xModel = mpDocSh->GetModel();
1045     }
1046     catch( uno::RuntimeException& )
1047     {
1048     }
1049
1050     return xModel;
1051 }
1052
1053 SvxNumType SdDrawDocument::GetPageNumType() const
1054 {
1055     return mePageNumType;
1056 }
1057
1058 void SdDrawDocument::SetPrinterIndependentLayout (sal_Int32 nMode)
1059 {
1060     switch (nMode)
1061     {
1062         case css::document::PrinterIndependentLayout::DISABLED:
1063         case css::document::PrinterIndependentLayout::ENABLED:
1064             // Just store supported modes and inform the doc shell
1065             mnPrinterIndependentLayout = nMode;
1066
1067             // Since it is possible that a SdDrawDocument is constructed without a
1068             // SdDrawDocShell the pointer member mpDocSh needs to be tested
1069             // before the call is executed. This is e. g. used for copy/paste.
1070             if(mpDocSh)
1071             {
1072                 mpDocSh->UpdateRefDevice ();
1073             }
1074
1075             break;
1076
1077         default:
1078             // Ignore unknown values
1079             break;
1080     }
1081 }
1082
1083 void SdDrawDocument::SetStartWithPresentation( bool bStartWithPresentation )
1084 {
1085     mbStartWithPresentation = bStartWithPresentation;
1086 }
1087
1088 void SdDrawDocument::SetExitAfterPresenting( bool bExitAfterPresenting )
1089 {
1090     mbExitAfterPresenting = bExitAfterPresenting;
1091 }
1092
1093 void SdDrawDocument::PageListChanged()
1094 {
1095     mpDrawPageListWatcher->Invalidate();
1096 }
1097
1098 void SdDrawDocument::MasterPageListChanged()
1099 {
1100     mpMasterPageListWatcher->Invalidate();
1101 }
1102
1103 void SdDrawDocument::SetCalcFieldValueHdl(::Outliner* pOutliner)
1104 {
1105     pOutliner->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
1106 }
1107
1108 sal_uInt16 SdDrawDocument::GetAnnotationAuthorIndex( const OUString& rAuthor )
1109 {
1110     // force current user to have first color
1111     if( maAnnotationAuthors.empty() )
1112     {
1113         SvtUserOptions aUserOptions;
1114         maAnnotationAuthors.push_back( aUserOptions.GetFullName() );
1115     }
1116
1117     sal_uInt16 idx = 0;
1118     const std::vector< OUString >::const_iterator aEnd( maAnnotationAuthors.end());
1119     for( std::vector< OUString >::const_iterator iter( maAnnotationAuthors.begin() ); iter != aEnd; ++iter )
1120     {
1121         if( (*iter) == rAuthor )
1122         {
1123             break;
1124         }
1125         idx++;
1126     }
1127
1128     if( idx == maAnnotationAuthors.size() )
1129     {
1130         maAnnotationAuthors.push_back( rAuthor );
1131     }
1132
1133     return idx;
1134 }
1135
1136 void SdDrawDocument::InitLayoutVector()
1137 {
1138     if (utl::ConfigManager::IsFuzzing())
1139         return;
1140
1141     const Reference<css::uno::XComponentContext> xContext(
1142         ::comphelper::getProcessComponentContext() );
1143
1144     // get file list from configuration
1145     Sequence< rtl::OUString > aFiles(
1146         officecfg::Office::Impress::Misc::LayoutListFiles::get(xContext) );
1147
1148     rtl::OUString sFilename;
1149     for( sal_Int32 i=0; i < aFiles.getLength(); ++i )
1150     {
1151         sFilename = comphelper::getExpandedUri(xContext, aFiles[i]);
1152
1153         // load layout file into DOM
1154         Reference< XMultiServiceFactory > xServiceFactory(
1155             xContext->getServiceManager() , UNO_QUERY_THROW );
1156         const Reference<XDocumentBuilder> xDocBuilder(
1157             DocumentBuilder::create( comphelper::getComponentContext (xServiceFactory) ));
1158
1159         try
1160         {
1161             // loop over every layout entry in current file
1162             const Reference<XDocument> xDoc = xDocBuilder->parseURI( sFilename );
1163             const Reference<XNodeList> layoutlist = xDoc->getElementsByTagName("layout");
1164             const int nElements = layoutlist->getLength();
1165             for(int index=0; index < nElements; index++)
1166                 maLayoutInfo.push_back( layoutlist->item(index) );
1167         }
1168         catch (const uno::Exception &)
1169         {
1170             // skip missing config. files
1171         }
1172     }
1173 }
1174
1175 void SdDrawDocument::InitObjectVector()
1176 {
1177     if (utl::ConfigManager::IsFuzzing())
1178         return;
1179
1180     const Reference<css::uno::XComponentContext> xContext(
1181         ::comphelper::getProcessComponentContext() );
1182
1183     // get file list from configuration
1184     Sequence< rtl::OUString > aFiles(
1185        officecfg::Office::Impress::Misc::PresObjListFiles::get(xContext) );
1186
1187     rtl::OUString sFilename;
1188     for( sal_Int32 i=0; i < aFiles.getLength(); ++i )
1189     {
1190         sFilename = comphelper::getExpandedUri(xContext, aFiles[i]);
1191
1192         // load presentation object file into DOM
1193         Reference< XMultiServiceFactory > xServiceFactory(
1194             xContext->getServiceManager() , UNO_QUERY_THROW );
1195         const Reference<XDocumentBuilder> xDocBuilder(
1196             DocumentBuilder::create( comphelper::getComponentContext (xServiceFactory) ));
1197
1198         try
1199         {
1200             // loop over every object entry in current file
1201             const Reference<XDocument> xDoc = xDocBuilder->parseURI( sFilename );
1202             const Reference<XNodeList> objectlist = xDoc->getElementsByTagName("object");
1203             const int nElements = objectlist->getLength();
1204             for(int index=0; index < nElements; index++)
1205                 maPresObjectInfo.push_back( objectlist->item(index) );
1206         }
1207         catch (const uno::Exception &)
1208         {
1209             // skip missing config. files
1210         }
1211     }
1212 }
1213
1214 void SdDrawDocument::dumpAsXml(xmlTextWriterPtr pWriter) const
1215 {
1216     bool bOwns = false;
1217     if (!pWriter)
1218     {
1219         pWriter = xmlNewTextWriterFilename("model.xml", 0);
1220         xmlTextWriterSetIndent(pWriter,1);
1221         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
1222         xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
1223         bOwns = true;
1224     }
1225     xmlTextWriterStartElement(pWriter, BAD_CAST("SdDrawDocument"));
1226     xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
1227
1228     if (mpOutliner)
1229         mpOutliner->dumpAsXml(pWriter);
1230     FmFormModel::dumpAsXml(pWriter);
1231     if (GetUndoManager())
1232         GetUndoManager()->dumpAsXml(pWriter);
1233
1234     xmlTextWriterEndElement(pWriter);
1235     if (bOwns)
1236     {
1237         xmlTextWriterEndDocument(pWriter);
1238         xmlFreeTextWriter(pWriter);
1239     }
1240 }
1241
1242 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */