sd/source/ui/docshell/docshel4.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 <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <memory>
  24 #include <utility>
  25
  26 #include <DrawDocShell.hxx>
  27 #include <com/sun/star/document/PrinterIndependentLayout.hpp>
  28 #include <editeng/outlobj.hxx>
  29 #include <tools/urlobj.hxx>
  30 #include <svx/compatflags.hxx>
  31 #include <svx/svxids.hrc>
  32 #include <editeng/editeng.hxx>
  33 #include <editeng/editstat.hxx>
  34 #include <editeng/flstitem.hxx>
  35 #include <svl/flagitem.hxx>
  36 #include <sot/storage.hxx>
  37 #include <sfx2/dinfdlg.hxx>
  38 #include <sfx2/docfile.hxx>
  39 #include <sfx2/docfilt.hxx>
  40 #include <sfx2/dispatch.hxx>
  41 #include <svx/svdotext.hxx>
  42 #include <sfx2/printer.hxx>
  43 #include <svtools/ctrltool.hxx>
  44 #include <comphelper/classids.hxx>
  45 #include <sot/formats.hxx>
  46 #include <sfx2/viewfrm.hxx>
  47 #include <vcl/syswin.hxx>
  48 #include <com/sun/star/drawing/XDrawPage.hpp>
  49 #include <com/sun/star/drawing/XDrawView.hpp>
  50
  51 #include <app.hrc>
  52 #include <strings.hrc>
  53 #include <FrameView.hxx>
  54 #include <optsitem.hxx>
  55 #include <Outliner.hxx>
  56 #include <sdattr.hrc>
  57 #include <drawdoc.hxx>
  58 #include <ViewShell.hxx>
  59 #include <sdmod.hxx>
  60 #include <View.hxx>
  61 #include <EffectMigration.hxx>
  62 #include <CustomAnimationEffect.hxx>
  63 #include <sdpage.hxx>
  64 #include <sdresid.hxx>
  65 #include <DrawViewShell.hxx>
  66 #include <ViewShellBase.hxx>
  67 #include <OutlineView.hxx>
  68 #include <OutlineViewShell.hxx>
  69 #include <sdxmlwrp.hxx>
  70 #include <sdpptwrp.hxx>
  71 #include <sdcgmfilter.hxx>
  72 #include <sdgrffilter.hxx>
  73 #include <sdhtmlfilter.hxx>
  74 #include <sdpdffilter.hxx>
  75 #include <framework/FrameworkHelper.hxx>
  76 #include <o3tl/string_view.hxx>
  77
  78 #include <Window.hxx>
  79 #include <svl/intitem.hxx>
  80
  81 using namespace ::com::sun::star;
  82 using namespace ::com::sun::star::uno;
  83 using ::sd::framework::FrameworkHelper;
  84
  85 // PowerPoint-Filter
  86 constexpr OUStringLiteral pFilterPowerPoint97( u"MS PowerPoint 97" );
  87 constexpr OUStringLiteral pFilterPowerPoint97Template( u"MS PowerPoint 97 Vorlage" );
  88 constexpr OUStringLiteral pFilterPowerPoint97AutoPlay( u"MS PowerPoint 97 AutoPlay" );
  89
  90 namespace sd {
  91
  92 /**
  93  * Creates (if necessary) and returns a SfxPrinter
  94  */
  95 SfxPrinter* DrawDocShell::GetPrinter(bool bCreate)
  96 {
  97     if (bCreate && !mpPrinter)
  98     {
  99         // create ItemSet with special pool area
 100         auto pSet = std::make_unique<SfxItemSetFixed<
 101                             SID_PRINTER_NOTFOUND_WARN,  SID_PRINTER_NOTFOUND_WARN,
 102                             SID_PRINTER_CHANGESTODOC,   SID_PRINTER_CHANGESTODOC,
 103                             ATTR_OPTIONS_PRINT,         ATTR_OPTIONS_PRINT>>( GetPool() );
 104         // set PrintOptionsSet
 105         SdOptionsPrintItem aPrintItem( SD_MOD()->GetSdOptions(mpDoc->GetDocumentType()) );
 106         SfxFlagItem aFlagItem( SID_PRINTER_CHANGESTODOC );
 107         SfxPrinterChangeFlags nFlags =
 108                 (aPrintItem.GetOptionsPrint().IsWarningSize() ? SfxPrinterChangeFlags::CHG_SIZE : SfxPrinterChangeFlags::NONE) |
 109                 (aPrintItem.GetOptionsPrint().IsWarningOrientation() ? SfxPrinterChangeFlags::CHG_ORIENTATION : SfxPrinterChangeFlags::NONE);
 110         aFlagItem.SetValue( static_cast<int>(nFlags) );
 111
 112         pSet->Put( aPrintItem );
 113         pSet->Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, aPrintItem.GetOptionsPrint().IsWarningPrinter() ) );
 114         pSet->Put( aFlagItem );
 115
 116         mpPrinter = VclPtr<SfxPrinter>::Create(std::move(pSet));
 117         mbOwnPrinter = true;
 118
 119         // set output quality
 120         sal_uInt16 nQuality = aPrintItem.GetOptionsPrint().GetOutputQuality();
 121
 122         DrawModeFlags nMode = DrawModeFlags::Default;
 123         // 1 == Grayscale, 2 == Black & White (with grayscale images)
 124         if( nQuality == 1 )
 125             nMode = DrawModeFlags::GrayLine | DrawModeFlags::GrayFill | DrawModeFlags::GrayText | DrawModeFlags::GrayBitmap | DrawModeFlags::GrayGradient;
 126         else if( nQuality == 2 )
 127             nMode = DrawModeFlags::BlackLine | DrawModeFlags::WhiteFill | DrawModeFlags::BlackText | DrawModeFlags::GrayBitmap | DrawModeFlags::WhiteGradient;
 128
 129         mpPrinter->SetDrawMode( nMode );
 130
 131         MapMode aMM (mpPrinter->GetMapMode());
 132         aMM.SetMapUnit(MapUnit::Map100thMM);
 133         mpPrinter->SetMapMode(aMM);
 134         UpdateRefDevice();
 135     }
 136     return mpPrinter;
 137 }
 138
 139 /**
 140  * Set new SfxPrinter (transfer of ownership)
 141  */
 142 void DrawDocShell::SetPrinter(SfxPrinter *pNewPrinter)
 143 {
 144     if ( mpViewShell )
 145     {
 146         ::sd::View* pView = mpViewShell->GetView();
 147         if ( pView->IsTextEdit() )
 148             pView->SdrEndTextEdit();
 149     }
 150
 151     if ( mpPrinter && mbOwnPrinter && (mpPrinter.get() != pNewPrinter) )
 152         mpPrinter.disposeAndClear();
 153
 154     mpPrinter = pNewPrinter;
 155     mbOwnPrinter = true;
 156     if ( mpDoc->GetPrinterIndependentLayout() == css::document::PrinterIndependentLayout::DISABLED )
 157         UpdateFontList();
 158     UpdateRefDevice();
 159 }
 160
 161 void DrawDocShell::UpdateFontList()
 162 {
 163     mpFontList.reset();
 164     OutputDevice* pRefDevice = nullptr;
 165     if ( mpDoc->GetPrinterIndependentLayout() == css::document::PrinterIndependentLayout::DISABLED )
 166         pRefDevice = GetPrinter(true);
 167     else
 168         pRefDevice = SD_MOD()->GetVirtualRefDevice();
 169     mpFontList.reset( new FontList(pRefDevice, nullptr) );
 170     SvxFontListItem aFontListItem( mpFontList.get(), SID_ATTR_CHAR_FONTLIST );
 171     PutItem( aFontListItem );
 172 }
 173
 174 Printer* DrawDocShell::GetDocumentPrinter()
 175 {
 176     return GetPrinter(false);
 177 }
 178
 179 void DrawDocShell::OnDocumentPrinterChanged(Printer* pNewPrinter)
 180 {
 181     // if we already have a printer, see if it's the same
 182     if( mpPrinter )
 183     {
 184         // easy case
 185         if( mpPrinter == pNewPrinter )
 186             return;
 187
 188         // compare if it's the same printer with the same job setup
 189         if( (mpPrinter->GetName() == pNewPrinter->GetName()) &&
 190             (mpPrinter->GetJobSetup() == pNewPrinter->GetJobSetup()))
 191             return;
 192     }
 193
 194     SfxPrinter* const pSfxPrinter = dynamic_cast<SfxPrinter*>(pNewPrinter);
 195     if (pSfxPrinter)
 196     {
 197         SetPrinter(pSfxPrinter);
 198
 199         // container owns printer
 200         mbOwnPrinter = false;
 201     }
 202 }
 203
 204 void DrawDocShell::UpdateRefDevice()
 205 {
 206     if( !mpDoc )
 207         return;
 208
 209     // Determine the device for which the output will be formatted.
 210     VclPtr< OutputDevice > pRefDevice;
 211     switch (mpDoc->GetPrinterIndependentLayout())
 212     {
 213         case css::document::PrinterIndependentLayout::DISABLED:
 214             pRefDevice = mpPrinter.get();
 215             break;
 216
 217         case css::document::PrinterIndependentLayout::ENABLED:
 218             pRefDevice = SD_MOD()->GetVirtualRefDevice();
 219             break;
 220
 221         default:
 222             // We are confronted with an invalid or un-implemented
 223             // layout mode.  Use the printer as formatting device
 224             // as a fall-back.
 225             SAL_WARN( "sd", "DrawDocShell::UpdateRefDevice(): Unexpected printer layout mode");
 226
 227             pRefDevice = mpPrinter.get();
 228             break;
 229     }
 230     mpDoc->SetRefDevice( pRefDevice.get() );
 231
 232     SdOutliner* pOutl = mpDoc->GetOutliner( false );
 233
 234     if( pOutl )
 235         pOutl->SetRefDevice( pRefDevice );
 236
 237     SdOutliner* pInternalOutl = mpDoc->GetInternalOutliner( false );
 238
 239     if( pInternalOutl )
 240         pInternalOutl->SetRefDevice( pRefDevice );
 241 }
 242
 243 /**
 244  * Creates new document, opens streams
 245  */
 246 bool DrawDocShell::InitNew( const css::uno::Reference< css::embed::XStorage >& xStorage )
 247 {
 248     bool bRet = SfxObjectShell::InitNew( xStorage );
 249
 250     ::tools::Rectangle aVisArea( Point(0, 0), Size(14100, 10000) );
 251     SetVisArea(aVisArea);
 252
 253     if (bRet)
 254     {
 255         if( !mbSdDataObj )
 256             mpDoc->NewOrLoadCompleted(DocCreationMode::New);  // otherwise calling
 257                                                 // NewOrLoadCompleted(NEW_LOADED) in
 258                                                 // SdDrawDocument::AllocModel()
 259     }
 260     return bRet;
 261 }
 262
 263 /**
 264  * loads pools and document
 265  */
 266 bool DrawDocShell::Load( SfxMedium& rMedium )
 267 {
 268     // If this is an ODF file being loaded, then by default, use legacy processing
 269     // (if required, it will be overridden in *::ReadUserDataSequence())
 270     if (IsOwnStorageFormat(rMedium))
 271     {
 272         mpDoc->SetCompatibilityFlag(SdrCompatibilityFlag::AnchoredTextOverflowLegacy, true); // for tdf#99729
 273         mpDoc->SetCompatibilityFlag(SdrCompatibilityFlag::LegacySingleLineFontwork, true); // for tdf#148000
 274     }
 275
 276     bool       bRet = false;
 277     bool       bStartPresentation = false;
 278     ErrCode nError = ERRCODE_NONE;
 279
 280     SfxItemSet* pSet = rMedium.GetItemSet();
 281
 282     if( pSet )
 283     {
 284         if( (  SfxItemState::SET == pSet->GetItemState(SID_PREVIEW ) ) && pSet->Get( SID_PREVIEW ).GetValue() )
 285         {
 286             mpDoc->SetStarDrawPreviewMode( true );
 287         }
 288
 289         if( SfxItemState::SET == pSet->GetItemState(SID_DOC_STARTPRESENTATION)&&
 290             pSet->Get( SID_DOC_STARTPRESENTATION ).GetValue() )
 291         {
 292             bStartPresentation = true;
 293             mpDoc->SetStartWithPresentation( true );
 294         }
 295     }
 296
 297     bRet = SfxObjectShell::Load( rMedium );
 298     if (bRet)
 299     {
 300         comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = getEmbeddedObjectContainer();
 301         rEmbeddedObjectContainer.setUserAllowsLinkUpdate(false);
 302         bRet = SdXMLFilter( rMedium, *this, SdXMLFilterMode::Normal, SotStorage::GetVersion( rMedium.GetStorage() ) ).Import( nError );
 303     }
 304
 305     if( bRet )
 306     {
 307         // for legacy markup in OOoXML filter, convert the animations now
 308         EffectMigration::DocumentLoaded(*GetDoc());
 309         UpdateTablePointers();
 310
 311         // If we're an embedded OLE object, use tight bounds
 312         // for our visArea. No point in showing the user lots of empty
 313         // space. Had to remove the check for empty VisArea below,
 314         // since XML load always sets a VisArea before.
 315         //TODO/LATER: looks a little bit strange!
 316         if( ( GetCreateMode() == SfxObjectCreateMode::EMBEDDED ) && SfxObjectShell::GetVisArea( ASPECT_CONTENT ).IsEmpty() )
 317         {
 318             SdPage* pPage = mpDoc->GetSdPage( 0, PageKind::Standard );
 319
 320             if( pPage )
 321                 SetVisArea( pPage->GetAllObjBoundRect() );
 322         }
 323
 324         FinishedLoading();
 325
 326         const INetURLObject aUrl;
 327         SfxObjectShell::SetAutoLoad( aUrl, 0, false );
 328     }
 329     else
 330     {
 331         if( nError == ERRCODE_IO_BROKENPACKAGE )
 332             SetError(ERRCODE_IO_BROKENPACKAGE);
 333
 334         // TODO/LATER: correct error handling?!
 335         //pStore->SetError(SVSTREAM_WRONGVERSION);
 336         else
 337             SetError(ERRCODE_ABORT);
 338     }
 339
 340     // tell SFX to change viewshell when in preview mode
 341     if( IsPreview() || bStartPresentation )
 342     {
 343         SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
 344         if( pMediumSet )
 345             pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, bStartPresentation ? 1 : 5 ) );
 346     }
 347
 348     return bRet;
 349 }
 350
 351 /**
 352  * loads content for organizer
 353  */
 354 bool DrawDocShell::LoadFrom( SfxMedium& rMedium )
 355 {
 356     std::unique_ptr<weld::WaitObject> pWait;
 357     if( mpViewShell )
 358         pWait.reset(new weld::WaitObject(mpViewShell->GetFrameWeld()));
 359
 360     mpDoc->NewOrLoadCompleted( DocCreationMode::New );
 361     mpDoc->CreateFirstPages();
 362     mpDoc->StopWorkStartupDelay();
 363
 364     // TODO/LATER: nobody is interested in the error code?!
 365     ErrCode nError = ERRCODE_NONE;
 366     bool bRet = SdXMLFilter( rMedium, *this, SdXMLFilterMode::Organizer, SotStorage::GetVersion( rMedium.GetStorage() ) ).Import( nError );
 367
 368     // tell SFX to change viewshell when in preview mode
 369     if( IsPreview() )
 370     {
 371         SfxItemSet *pSet = GetMedium()->GetItemSet();
 372
 373         if( pSet )
 374             pSet->Put( SfxUInt16Item( SID_VIEW_ID, 5 ) );
 375     }
 376
 377     return bRet;
 378 }
 379
 380 /**
 381  * load from 3rd party format
 382  */
 383 bool DrawDocShell::ImportFrom(SfxMedium &rMedium,
 384         uno::Reference<text::XTextRange> const& xInsertPosition)
 385 {
 386     const OUString aFilterName( rMedium.GetFilter()->GetFilterName() );
 387     if (aFilterName == "Impress MS PowerPoint 2007 XML" ||
 388         aFilterName == "Impress MS PowerPoint 2007 XML AutoPlay" ||
 389         aFilterName == "Impress MS PowerPoint 2007 XML VBA")
 390     {
 391         // As this is a MSFT format, we should use the "MS Compat"
 392         // mode for spacing before and after paragraphs.
 393
 394         // This is copied from what is done for .ppt import in
 395         // ImplSdPPTImport::Import() in sd/source/filter/ppt/pptin.cxx
 396         // in. We need to tell both the edit engine of the draw outliner,
 397         // and the document, to do "summation of paragraphs".
 398         SdrOutliner& rOutl = mpDoc->GetDrawOutliner();
 399         EEControlBits nControlWord = rOutl.GetEditEngine().GetControlWord();
 400         nControlWord |=  EEControlBits::ULSPACESUMMATION;
 401         const_cast<EditEngine&>(rOutl.GetEditEngine()).SetControlWord( nControlWord );
 402
 403         mpDoc->SetSummationOfParagraphs();
 404     }
 405
 406     if (aFilterName == "Impress MS PowerPoint 2007 XML")
 407     {
 408         // This is a "MS Compact" mode for connectors.
 409         // The Libreoffice uses bounding rectangle of connected shapes but
 410         // MSO uses snap rectangle when calculate the edge track.
 411         mpDoc->SetCompatibilityFlag(SdrCompatibilityFlag::ConnectorUseSnapRect, true);
 412
 413         // compatibility flag for tdf#148966
 414         mpDoc->SetCompatibilityFlag(SdrCompatibilityFlag::IgnoreBreakAfterMultilineField, true);
 415     }
 416
 417     if (aFilterName == "Impress MS PowerPoint 2007 XML" ||
 418         aFilterName == "Impress MS PowerPoint 2007 XML AutoPlay" ||
 419         aFilterName == "Impress MS PowerPoint 2007 XML VBA" ||
 420         aFilterName == "Impress Office Open XML")
 421     {
 422         // We need to be able to set the default tab size for each text object.
 423         // This is possible at the moment only for the whole document. See
 424         // TextParagraphPropertiesContext constructor. So default tab width
 425         // of the LibreOffice is 1270 but MSO is 2540 on general settings.
 426         mpDoc->SetDefaultTabulator( 2540 );
 427     }
 428
 429     const bool bRet = SfxObjectShell::ImportFrom(rMedium, xInsertPosition);
 430
 431     SfxItemSet* pSet = rMedium.GetItemSet();
 432     if( pSet )
 433     {
 434         if( SfxItemState::SET == pSet->GetItemState(SID_DOC_STARTPRESENTATION)&&
 435             pSet->Get( SID_DOC_STARTPRESENTATION ).GetValue() )
 436         {
 437             mpDoc->SetStartWithPresentation( true );
 438
 439             // tell SFX to change viewshell when in preview mode
 440             if( IsPreview() )
 441             {
 442                 SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
 443                 if( pMediumSet )
 444                     pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, 1 ) );
 445             }
 446         }
 447     }
 448
 449     return bRet;
 450 }
 451
 452 /**
 453  * load from a foreign format
 454  */
 455 bool DrawDocShell::ConvertFrom( SfxMedium& rMedium )
 456 {
 457     const OUString  aFilterName( rMedium.GetFilter()->GetFilterName() );
 458     bool            bRet = false;
 459     bool            bStartPresentation = false;
 460
 461     SetWaitCursor( true );
 462
 463     SfxItemSet* pSet = rMedium.GetItemSet();
 464     if( pSet )
 465     {
 466         if( (  SfxItemState::SET == pSet->GetItemState(SID_PREVIEW ) ) && pSet->Get( SID_PREVIEW ).GetValue() )
 467         {
 468             mpDoc->SetStarDrawPreviewMode( true );
 469         }
 470
 471         if( SfxItemState::SET == pSet->GetItemState(SID_DOC_STARTPRESENTATION)&&
 472             pSet->Get( SID_DOC_STARTPRESENTATION ).GetValue() )
 473         {
 474             bStartPresentation = true;
 475             mpDoc->SetStartWithPresentation( true );
 476         }
 477     }
 478
 479     if( aFilterName == pFilterPowerPoint97
 480         || aFilterName == pFilterPowerPoint97Template
 481         || aFilterName == pFilterPowerPoint97AutoPlay)
 482     {
 483         mpDoc->StopWorkStartupDelay();
 484         bRet = SdPPTFilter( rMedium, *this ).Import();
 485     }
 486     else if (aFilterName.indexOf("impress8") >= 0 ||
 487              aFilterName.indexOf("draw8") >= 0)
 488     {
 489         // TODO/LATER: nobody is interested in the error code?!
 490         mpDoc->CreateFirstPages();
 491         mpDoc->StopWorkStartupDelay();
 492         ErrCode nError = ERRCODE_NONE;
 493         bRet = SdXMLFilter( rMedium, *this ).Import( nError );
 494
 495     }
 496     else if (aFilterName.indexOf("StarOffice XML (Draw)") >= 0 ||
 497              aFilterName.indexOf("StarOffice XML (Impress)") >= 0)
 498     {
 499         // TODO/LATER: nobody is interested in the error code?!
 500         mpDoc->CreateFirstPages();
 501         mpDoc->StopWorkStartupDelay();
 502         ErrCode nError = ERRCODE_NONE;
 503         bRet = SdXMLFilter( rMedium, *this, SdXMLFilterMode::Normal, SOFFICE_FILEFORMAT_60 ).Import( nError );
 504     }
 505     else if (aFilterName == "CGM - Computer Graphics Metafile")
 506     {
 507         mpDoc->CreateFirstPages();
 508         mpDoc->StopWorkStartupDelay();
 509         bRet = SdCGMFilter( rMedium, *this ).Import();
 510     }
 511     else if (aFilterName == "draw_pdf_import")
 512     {
 513         mpDoc->CreateFirstPages();
 514         mpDoc->StopWorkStartupDelay();
 515         bRet = SdPdfFilter(rMedium, *this).Import();
 516     }
 517     else
 518     {
 519         mpDoc->CreateFirstPages();
 520         mpDoc->StopWorkStartupDelay();
 521         bRet = SdGRFFilter( rMedium, *this ).Import();
 522     }
 523
 524     FinishedLoading();
 525
 526     // tell SFX to change viewshell when in preview mode
 527     if( IsPreview() )
 528     {
 529         SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
 530
 531         if( pMediumSet )
 532             pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, 5 ) );
 533     }
 534     SetWaitCursor( false );
 535
 536     // tell SFX to change viewshell when in preview mode
 537     if( IsPreview() || bStartPresentation )
 538     {
 539         SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
 540         if( pMediumSet )
 541             pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, bStartPresentation ? 1 : 5 ) );
 542     }
 543
 544     return bRet;
 545 }
 546
 547 /**
 548  * Writes pools and document to the open streams
 549  */
 550 bool DrawDocShell::Save()
 551 {
 552     mpDoc->StopWorkStartupDelay();
 553
 554     //TODO/LATER: why this?!
 555     if( GetCreateMode() == SfxObjectCreateMode::STANDARD )
 556         SfxObjectShell::SetVisArea( ::tools::Rectangle() );
 557
 558     bool bRet = SfxObjectShell::Save();
 559
 560     if( bRet )
 561         bRet = SdXMLFilter( *GetMedium(), *this, SdXMLFilterMode::Normal, SotStorage::GetVersion( GetMedium()->GetStorage() ) ).Export();
 562
 563     return bRet;
 564 }
 565
 566 /**
 567  * Writes pools and document to the provided storage
 568  */
 569 bool DrawDocShell::SaveAs( SfxMedium& rMedium )
 570 {
 571     mpDoc->setDocAccTitle(OUString());
 572     if (SfxViewFrame* pFrame1 = SfxViewFrame::GetFirst(this))
 573     {
 574         if (vcl::Window* pSysWin = pFrame1->GetWindow().GetSystemWindow())
 575         {
 576             pSysWin->SetAccessibleName(OUString());
 577         }
 578     }
 579     mpDoc->StopWorkStartupDelay();
 580
 581     //With custom animation, if Outliner is modified, update text before saving
 582     if( mpViewShell )
 583     {
 584         SdPage* pPage = mpViewShell->getCurrentPage();
 585         if( pPage && pPage->getMainSequence()->getCount() )
 586         {
 587             SdrObject* pObj = mpViewShell->GetView()->GetTextEditObject();
 588             SdrOutliner* pOutl = mpViewShell->GetView()->GetTextEditOutliner();
 589             if( pObj && pOutl && pOutl->IsModified() )
 590             {
 591                 std::optional<OutlinerParaObject> pNewText = pOutl->CreateParaObject( 0, pOutl->GetParagraphCount() );
 592                 pObj->SetOutlinerParaObject( std::move(pNewText) );
 593                 pOutl->ClearModifyFlag();
 594             }
 595         }
 596     }
 597
 598     //TODO/LATER: why this?!
 599     if( GetCreateMode() == SfxObjectCreateMode::STANDARD )
 600         SfxObjectShell::SetVisArea( ::tools::Rectangle() );
 601
 602     bool bRet = SfxObjectShell::SaveAs( rMedium );
 603
 604     if( bRet )
 605         bRet = SdXMLFilter( rMedium, *this, SdXMLFilterMode::Normal, SotStorage::GetVersion( rMedium.GetStorage() ) ).Export();
 606
 607     if( GetError() == ERRCODE_NONE )
 608         SetError(ERRCODE_NONE);
 609
 610     return bRet;
 611 }
 612
 613 /**
 614  * save to foreign format
 615  */
 616 bool DrawDocShell::ConvertTo( SfxMedium& rMedium )
 617 {
 618     bool bRet = false;
 619
 620     if( mpDoc->GetPageCount() )
 621     {
 622         std::shared_ptr<const SfxFilter> pMediumFilter = rMedium.GetFilter();
 623         const OUString aTypeName( pMediumFilter->GetTypeName() );
 624         std::unique_ptr<SdFilter> xFilter;
 625
 626         if( aTypeName.indexOf( "graphic_HTML" ) >= 0 )
 627         {
 628             xFilter = std::make_unique<SdHTMLFilter>(rMedium, *this);
 629         }
 630         else if( aTypeName.indexOf( "MS_PowerPoint_97" ) >= 0 )
 631         {
 632             xFilter = std::make_unique<SdPPTFilter>(rMedium, *this);
 633             static_cast<SdPPTFilter*>(xFilter.get())->PreSaveBasic();
 634         }
 635         else if ( aTypeName.indexOf( "CGM_Computer_Graphics_Metafile" ) >= 0 )
 636         {
 637             xFilter = std::make_unique<SdCGMFilter>(rMedium, *this);
 638         }
 639         else if( aTypeName.indexOf( "draw8" ) >= 0 ||
 640                  aTypeName.indexOf( "impress8" ) >= 0 )
 641         {
 642             xFilter = std::make_unique<SdXMLFilter>(rMedium, *this);
 643         }
 644         else if( aTypeName.indexOf( "StarOffice_XML_Impress" ) >= 0 ||
 645                  aTypeName.indexOf( "StarOffice_XML_Draw" ) >= 0 )
 646         {
 647             xFilter = std::make_unique<SdXMLFilter>(rMedium, *this, SdXMLFilterMode::Normal, SOFFICE_FILEFORMAT_60);
 648         }
 649         else
 650         {
 651             xFilter = std::make_unique<SdGRFFilter>(rMedium, *this);
 652         }
 653
 654         if (xFilter)
 655         {
 656             if ( mpViewShell )
 657             {
 658                 ::sd::View* pView = mpViewShell->GetView();
 659                 if ( pView->IsTextEdit() )
 660                     pView->SdrEndTextEdit();
 661             }
 662
 663             bRet = xFilter->Export();
 664         }
 665     }
 666
 667     return bRet;
 668 }
 669
 670 /**
 671  * Reopen own streams to ensure that nobody else can prevent use from opening
 672  * them.
 673  */
 674 bool DrawDocShell::SaveCompleted( const css::uno::Reference< css::embed::XStorage >& xStorage )
 675 {
 676     bool bRet = false;
 677
 678     if( SfxObjectShell::SaveCompleted(xStorage) )
 679     {
 680         mpDoc->NbcSetChanged( false );
 681
 682         if( mpViewShell )
 683         {
 684             if( dynamic_cast< OutlineViewShell *>( mpViewShell ) !=  nullptr )
 685                 static_cast<OutlineView*>(mpViewShell->GetView())
 686                     ->GetOutliner().ClearModifyFlag();
 687
 688             SdrOutliner* pOutl = mpViewShell->GetView()->GetTextEditOutliner();
 689             if( pOutl )
 690             {
 691                 SdrObject* pObj = mpViewShell->GetView()->GetTextEditObject();
 692                 if( pObj )
 693                     pObj->NbcSetOutlinerParaObject( pOutl->CreateParaObject() );
 694
 695                 pOutl->ClearModifyFlag();
 696             }
 697         }
 698
 699         bRet = true;
 700
 701         SfxViewFrame* pFrame = ( mpViewShell && mpViewShell->GetViewFrame() ) ?
 702                                mpViewShell->GetViewFrame() :
 703                                SfxViewFrame::Current();
 704
 705         if( pFrame )
 706             pFrame->GetBindings().Invalidate( SID_NAVIGATOR_STATE, true );
 707     }
 708     return bRet;
 709 }
 710
 711 SfxStyleSheetBasePool* DrawDocShell::GetStyleSheetPool()
 712 {
 713     return mpDoc->GetStyleSheetPool();
 714 }
 715
 716 void DrawDocShell::GotoBookmark(std::u16string_view rBookmark)
 717 {
 718     auto pDrawViewShell = dynamic_cast<DrawViewShell *>( mpViewShell );
 719     if (!pDrawViewShell)
 720         return;
 721
 722     ViewShellBase& rBase (mpViewShell->GetViewShellBase());
 723
 724     bool bIsMasterPage = false;
 725     sal_uInt16 nPageNumber = SDRPAGE_NOTFOUND;
 726     SdrObject* pObj = nullptr;
 727
 728     static constexpr std::u16string_view sInteraction( u"action?" );
 729     if ( o3tl::starts_with(rBookmark, sInteraction ) )
 730     {
 731         static constexpr std::u16string_view sJump( u"jump=" );
 732         if ( o3tl::starts_with(rBookmark.substr( sInteraction.size() ), sJump ) )
 733         {
 734             std::u16string_view aDestination( rBookmark.substr( sInteraction.size() + sJump.size() ) );
 735             if ( o3tl::starts_with(aDestination, u"firstslide" ) )
 736             {
 737                 nPageNumber = 1;
 738             }
 739             else if ( o3tl::starts_with(aDestination, u"lastslide" ) )
 740             {
 741                 nPageNumber = mpDoc->GetPageCount() - 2;
 742             }
 743             else if ( o3tl::starts_with(aDestination, u"previousslide" ) )
 744             {
 745                 SdPage* pPage = pDrawViewShell->GetActualPage();
 746                 nPageNumber = pPage->GetPageNum();
 747                 nPageNumber = nPageNumber > 2 ? nPageNumber - 2 : SDRPAGE_NOTFOUND;
 748             }
 749             else if ( o3tl::starts_with(aDestination, u"nextslide" ) )
 750             {
 751                 SdPage* pPage = pDrawViewShell->GetActualPage();
 752                 nPageNumber = pPage->GetPageNum() + 2;
 753                 if ( nPageNumber >= mpDoc->GetPageCount() )
 754                     nPageNumber = SDRPAGE_NOTFOUND;
 755             }
 756         }
 757     }
 758     else
 759     {
 760         // Is the bookmark a page?
 761         nPageNumber = mpDoc->GetPageByName( rBookmark, bIsMasterPage );
 762
 763         if (nPageNumber == SDRPAGE_NOTFOUND)
 764         {
 765             // Is the bookmark an object?
 766             pObj = mpDoc->GetObj(rBookmark);
 767
 768             if (pObj)
 769             {
 770                 nPageNumber = pObj->getSdrPageFromSdrObject()->GetPageNum();
 771             }
 772         }
 773     }
 774     if (nPageNumber != SDRPAGE_NOTFOUND)
 775     {
 776         // Jump to the bookmarked page.  This is done in three steps.
 777
 778         SdPage* pPage;
 779         if (bIsMasterPage)
 780             pPage = static_cast<SdPage*>( mpDoc->GetMasterPage(nPageNumber) );
 781         else
 782             pPage = static_cast<SdPage*>( mpDoc->GetPage(nPageNumber) );
 783
 784         // 1.) Change the view shell to the edit view, the notes view,
 785         // or the handout view.
 786         PageKind eNewPageKind = pPage->GetPageKind();
 787
 788         if( (eNewPageKind != PageKind::Standard) && (mpDoc->GetDocumentType() == DocumentType::Draw) )
 789             return;
 790
 791         if (eNewPageKind != pDrawViewShell->GetPageKind())
 792         {
 793             // change work area
 794             GetFrameView()->SetPageKind(eNewPageKind);
 795             OUString sViewURL;
 796             switch (eNewPageKind)
 797             {
 798                 case PageKind::Standard:
 799                     sViewURL = FrameworkHelper::msImpressViewURL;
 800                     break;
 801                 case PageKind::Notes:
 802                     sViewURL = FrameworkHelper::msNotesViewURL;
 803                     break;
 804                 case PageKind::Handout:
 805                     sViewURL = FrameworkHelper::msHandoutViewURL;
 806                     break;
 807                 default:
 808                     break;
 809             }
 810             if (!sViewURL.isEmpty())
 811             {
 812                 std::shared_ptr<FrameworkHelper> pHelper (
 813                     FrameworkHelper::Instance(rBase));
 814                 pHelper->RequestView(
 815                     sViewURL,
 816                     FrameworkHelper::msCenterPaneURL);
 817                 pHelper->WaitForUpdate();
 818
 819                 // Get the new DrawViewShell.
 820                 mpViewShell = pHelper->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
 821                 pDrawViewShell = dynamic_cast<sd::DrawViewShell*>(mpViewShell);
 822             }
 823             else
 824             {
 825                 pDrawViewShell = nullptr;
 826             }
 827         }
 828
 829         if (pDrawViewShell != nullptr)
 830         {
 831             setEditMode(pDrawViewShell, bIsMasterPage);
 832
 833             // Make the bookmarked page the current page.  This is done
 834             // by using the API because this takes care of all the
 835             // little things to be done.  Especially writing the view
 836             // data to the frame view.
 837             sal_uInt16 nSdPgNum = (nPageNumber - 1) / 2;
 838             Reference<drawing::XDrawView> xController (rBase.GetController(), UNO_QUERY);
 839             if (xController.is())
 840             {
 841                 Reference<drawing::XDrawPage> xDrawPage (pPage->getUnoPage(), UNO_QUERY);
 842                 xController->setCurrentPage (xDrawPage);
 843             }
 844             else
 845             {
 846                 // As a fall back switch to the page via the core.
 847                 DBG_ASSERT (xController.is(),
 848                     "DrawDocShell::GotoBookmark: can't switch page via API");
 849                 pDrawViewShell->SwitchPage(nSdPgNum);
 850             }
 851
 852             // Do UnmarkAll here to stop the Navigator from reselecting the previously marked
 853             // entry when a slide entry is selected.
 854             pDrawViewShell->GetView()->UnmarkAll();
 855             if (pObj != nullptr)
 856             {
 857                 // show and select object
 858                 if (vcl::Window* pWindow = pDrawViewShell->GetActiveWindow())
 859                     pDrawViewShell->MakeVisible(pObj->GetSnapRect(), *pWindow);
 860                 pDrawViewShell->GetView()->MarkObj(
 861                     pObj,
 862                     pDrawViewShell->GetView()->GetSdrPageView());
 863             }
 864         }
 865     }
 866
 867     if (SfxViewFrame* pViewFrame = (pDrawViewShell && pDrawViewShell->GetViewFrame())
 868         ? pDrawViewShell->GetViewFrame()
 869         : SfxViewFrame::Current())
 870     {
 871         SfxBindings& rBindings = pViewFrame->GetBindings();
 872         rBindings.Invalidate(SID_NAVIGATOR_STATE, true);
 873         rBindings.Invalidate(SID_NAVIGATOR_PAGENAME);
 874     }
 875 }
 876
 877 /**
 878  * If it should become a document template.
 879  */
 880 bool DrawDocShell::SaveAsOwnFormat( SfxMedium& rMedium )
 881 {
 882
 883     std::shared_ptr<const SfxFilter> pFilter = rMedium.GetFilter();
 884
 885     if (pFilter->IsOwnTemplateFormat())
 886     {
 887         /* now the StarDraw specialty:
 888            we assign known layout names to the layout template of the first
 889            page, we set the layout names of the affected masterpages and pages.
 890            We inform all text objects of the affected standard, note and
 891            masterpages about the name change.
 892         */
 893
 894         OUString aLayoutName;
 895
 896         SfxStringItem const * pLayoutItem = rMedium.GetItemSet()->GetItemIfSet(SID_TEMPLATE_NAME, false);
 897         if( pLayoutItem )
 898         {
 899             aLayoutName = pLayoutItem->GetValue();
 900         }
 901         else
 902         {
 903             INetURLObject aURL( rMedium.GetName() );
 904             aURL.removeExtension();
 905             aLayoutName = aURL.getName();
 906         }
 907
 908         if (aLayoutName.isEmpty())
 909         {
 910             sal_uInt32 nCount = mpDoc->GetMasterSdPageCount(PageKind::Standard);
 911             for (sal_uInt32 i = 0; i < nCount; ++i)
 912             {
 913                 OUString aOldPageLayoutName = mpDoc->GetMasterSdPage(i, PageKind::Standard)->GetLayoutName();
 914                 OUString aNewLayoutName = aLayoutName;
 915                 // Don't add suffix for the first master page
 916                 if( i > 0 )
 917                     aNewLayoutName += OUString::number(i);
 918
 919                 mpDoc->RenameLayoutTemplate(aOldPageLayoutName, aNewLayoutName);
 920             }
 921         }
 922     }
 923
 924     return SfxObjectShell::SaveAsOwnFormat(rMedium);
 925 }
 926
 927 void DrawDocShell::FillClass(SvGlobalName* pClassName,
 928                                         SotClipboardFormatId* pFormat,
 929                                         OUString* pFullTypeName,
 930                                         sal_Int32 nFileFormat,
 931                                         bool bTemplate /* = false */) const
 932 {
 933     if (nFileFormat == SOFFICE_FILEFORMAT_60)
 934     {
 935         if ( meDocType == DocumentType::Draw )
 936         {
 937             *pClassName = SvGlobalName(SO3_SDRAW_CLASSID_60);
 938             *pFormat = SotClipboardFormatId::STARDRAW_60;
 939             *pFullTypeName = SdResId(STR_GRAPHIC_DOCUMENT_FULLTYPE_60);
 940         }
 941         else
 942         {
 943             *pClassName = SvGlobalName(SO3_SIMPRESS_CLASSID_60);
 944             *pFormat = SotClipboardFormatId::STARIMPRESS_60;
 945             *pFullTypeName = SdResId(STR_IMPRESS_DOCUMENT_FULLTYPE_60);
 946         }
 947     }
 948     else if (nFileFormat == SOFFICE_FILEFORMAT_8)
 949     {
 950         if ( meDocType == DocumentType::Draw )
 951         {
 952             *pClassName = SvGlobalName(SO3_SDRAW_CLASSID_60);
 953             *pFormat = bTemplate ? SotClipboardFormatId::STARDRAW_8_TEMPLATE : SotClipboardFormatId::STARDRAW_8;
 954             *pFullTypeName = SdResId(STR_GRAPHIC_DOCUMENT_FULLTYPE_80); // HACK: method will be removed with new storage API
 955         }
 956         else
 957         {
 958             *pClassName = SvGlobalName(SO3_SIMPRESS_CLASSID_60);
 959             *pFormat = bTemplate ? SotClipboardFormatId::STARIMPRESS_8_TEMPLATE : SotClipboardFormatId::STARIMPRESS_8;
 960             *pFullTypeName = SdResId(STR_IMPRESS_DOCUMENT_FULLTYPE_80); // HACK: method will be removed with new storage API
 961         }
 962     }
 963 }
 964
 965 OutputDevice* DrawDocShell::GetDocumentRefDev()
 966 {
 967     OutputDevice* pReferenceDevice = SfxObjectShell::GetDocumentRefDev ();
 968     // Only when our parent does not have a reference device then we return
 969     // our own.
 970     if (pReferenceDevice == nullptr && mpDoc != nullptr)
 971         pReferenceDevice = mpDoc->GetRefDevice ();
 972     return pReferenceDevice;
 973 }
 974
 975 /** executes the SID_OPENDOC slot to let the framework open a document
 976     with the given URL and this document as a referer */
 977 void DrawDocShell::OpenBookmark( const OUString& rBookmarkURL )
 978 {
 979     SfxStringItem   aStrItem( SID_FILE_NAME, rBookmarkURL );
 980     SfxStringItem   aReferer( SID_REFERER, GetMedium()->GetName() );
 981     const SfxPoolItem* ppArgs[] = { &aStrItem, &aReferer, nullptr };
 982     if (SfxViewFrame* pFrame = mpViewShell ? mpViewShell->GetViewFrame() : SfxViewFrame::Current())
 983         pFrame->GetBindings().Execute( SID_OPENHYPERLINK, ppArgs );
 984 }
 985
 986 std::shared_ptr<SfxDocumentInfoDialog> DrawDocShell::CreateDocumentInfoDialog(weld::Window* pParent, const SfxItemSet &rSet)
 987 {
 988     std::shared_ptr<SfxDocumentInfoDialog> xDlg = std::make_shared<SfxDocumentInfoDialog>(pParent, rSet);
 989     DrawDocShell* pDocSh = dynamic_cast<DrawDocShell*>(SfxObjectShell::Current());
 990     if( pDocSh == this )
 991     {
 992         xDlg->AddFontTabPage();
 993     }
 994     return xDlg;
 995 }
 996
 997 void DrawDocShell::setEditMode(DrawViewShell* pDrawViewShell, bool isMasterPage)
 998 {
 999     // Set the edit mode to either the normal edit mode or the
1000     // master page mode.
1001     EditMode eNewEditMode = EditMode::Page;
1002     if (isMasterPage)
1003     {
1004         eNewEditMode = EditMode::MasterPage;
1005     }
1006
1007     if (eNewEditMode != pDrawViewShell->GetEditMode())
1008     {
1009         // Set EditMode
1010         pDrawViewShell->ChangeEditMode(eNewEditMode, false);
1011     }
1012 }
1013 } // end of namespace sd
1014
1015 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */