sd/source/ui/app/sdmod1.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 <svl/lckbitem.hxx>
  21 #include <svl/intitem.hxx>
  22 #include <sfx2/frame.hxx>
  23 #include <sfx2/viewfrm.hxx>
  24 #include <unotools/moduleoptions.hxx>
  25 #include <framework/FrameworkHelper.hxx>
  26
  27 #include <vcl/commandevent.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <vcl/errinf.hxx>
  30 #include <editeng/langitem.hxx>
  31 #include <vcl/weld.hxx>
  32 #include <sfx2/dispatch.hxx>
  33 #include <sfx2/docfile.hxx>
  34 #include <sfx2/request.hxx>
  35 #include <sfx2/templatedlg.hxx>
  36 #include <editeng/eeitem.hxx>
  37
  38 #include <svx/svxids.hrc>
  39 #include <strings.hrc>
  40
  41 #include <sdmod.hxx>
  42 #include <pres.hxx>
  43 #include <optsitem.hxx>
  44 #include <ViewShell.hxx>
  45 #include <DrawDocShell.hxx>
  46 #include <drawdoc.hxx>
  47 #include <sdresid.hxx>
  48 #include <OutlineView.hxx>
  49 #include <OutlineViewShell.hxx>
  50 #include <ViewShellBase.hxx>
  51 #include <FactoryIds.hxx>
  52 #include <memory>
  53 #include <slideshow.hxx>
  54
  55 using ::sd::framework::FrameworkHelper;
  56 using ::com::sun::star::uno::Reference;
  57 using ::com::sun::star::frame::XFrame;
  58
  59 namespace {
  60
  61 class OutlineToImpressFinalizer final
  62 {
  63 public:
  64     OutlineToImpressFinalizer (
  65         ::sd::ViewShellBase& rBase,
  66         SdDrawDocument& rDocument,
  67         SvLockBytes const & rBytes);
  68     void operator() (bool bEventSeen);
  69 private:
  70     ::sd::ViewShellBase& mrBase;
  71     SdDrawDocument& mrDocument;
  72     std::shared_ptr<SvMemoryStream> mpStream;
  73 };
  74
  75 } //end of anonymous namespace
  76
  77 void SdModule::Execute(SfxRequest& rReq)
  78 {
  79     const SfxItemSet* pSet = rReq.GetArgs();
  80     sal_uLong nSlotId = rReq.GetSlot();
  81
  82     switch ( nSlotId )
  83     {
  84         case SID_NEWDOC:
  85         {
  86             SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
  87         }
  88         break;
  89
  90         case SID_AUTOSPELL_CHECK:
  91         {
  92             // automatic spell checker
  93             const SfxPoolItem* pItem;
  94             if( pSet && SfxItemState::SET == pSet->GetItemState(
  95                         SID_AUTOSPELL_CHECK, false, &pItem ) )
  96             {
  97                 bool bOnlineSpelling = static_cast<const SfxBoolItem*>( pItem )->GetValue();
  98                 // save at document:
  99                 ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 100                 if( pDocSh )
 101                 {
 102                     SdDrawDocument* pDoc = pDocSh->GetDoc();
 103                     pDoc->SetOnlineSpell( bOnlineSpelling );
 104                 }
 105             }
 106         }
 107         break;
 108
 109         case SID_ATTR_METRIC:
 110         {
 111             const SfxPoolItem* pItem;
 112             if ( pSet && SfxItemState::SET == pSet->GetItemState( SID_ATTR_METRIC, true, &pItem ) )
 113             {
 114                 FieldUnit eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
 115                 switch( eUnit )
 116                 {
 117                     case FieldUnit::MM:      // only the units which are also in the dialog
 118                     case FieldUnit::CM:
 119                     case FieldUnit::INCH:
 120                     case FieldUnit::PICA:
 121                     case FieldUnit::POINT:
 122                         {
 123                             ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 124                             if(pDocSh)
 125                             {
 126                                 DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
 127
 128                                 PutItem( *pItem );
 129                                 SdOptions* pOptions = GetSdOptions( eDocType );
 130                                 if(pOptions)
 131                                     pOptions->SetMetric( static_cast<sal_uInt16>(eUnit) );
 132                                 rReq.Done();
 133                             }
 134                         }
 135                         break;
 136                     default:
 137                         break;
 138                     }
 139                 }
 140
 141         }
 142         break;
 143
 144         case SID_ATTR_LANGUAGE:
 145         case SID_ATTR_CHAR_CJK_LANGUAGE:
 146         case SID_ATTR_CHAR_CTL_LANGUAGE:
 147         {
 148             const SfxPoolItem* pItem;
 149             if( pSet &&
 150                 (
 151                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_LANGUAGE, false, &pItem ) ||
 152                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CJK_LANGUAGE, false, &pItem ) ||
 153                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CTL_LANGUAGE, false, &pItem )
 154                 )
 155               )
 156             {
 157                 // save at the document:
 158                 ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 159                 if ( pDocSh )
 160                 {
 161                     LanguageType eLanguage = static_cast<const SvxLanguageItem*>(pItem)->GetValue();
 162                     SdDrawDocument* pDoc = pDocSh->GetDoc();
 163
 164                     if( nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE )
 165                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CJK );
 166                     else if( nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE )
 167                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CTL );
 168                     else
 169                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE );
 170
 171                     if( pDoc->GetOnlineSpell() )
 172                     {
 173                         pDoc->StopOnlineSpelling();
 174                         pDoc->StartOnlineSpelling();
 175                     }
 176                 }
 177             }
 178         }
 179         break;
 180
 181         case SID_NEWSD:
 182             {
 183                 SfxFrame* pFrame = ExecuteNewDocument( rReq );
 184                 // if a frame was created, set it as return value
 185                 if(pFrame)
 186                     rReq.SetReturnValue(SfxFrameItem(0, pFrame));
 187             }
 188
 189             break;
 190
 191         case SID_OPENHYPERLINK:
 192         case SID_OPENDOC:
 193         {
 194             bool bIntercept = false;
 195             ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 196             if (pDocShell)
 197             {
 198                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 199                 if (pViewShell)
 200                 {
 201                     if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
 202                     {
 203                         // Prevent documents from opening while the slide
 204                         // show is running, except when this request comes
 205                         // from a shape interaction.
 206                         if (rReq.GetArgs() == nullptr)
 207                         {
 208                             bIntercept = true;
 209                         }
 210                     }
 211                 }
 212             }
 213
 214             if (!bIntercept)
 215             {
 216                 SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
 217             }
 218             else
 219             {
 220                 std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(nullptr,
 221                                                                VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_CANT_PERFORM_IN_LIVEMODE)));
 222
 223                 xErrorBox->run();
 224
 225                 const SfxLinkItem* pLinkItem = rReq.GetArg<SfxLinkItem>(SID_DONELINK);
 226                 if( pLinkItem )
 227                     pLinkItem->GetValue().Call( nullptr );
 228             }
 229         }
 230         break;
 231
 232         case SID_OUTLINE_TO_IMPRESS:
 233             OutlineToImpress (rReq);
 234             break;
 235
 236         default:
 237         break;
 238     }
 239 }
 240
 241 bool SdModule::OutlineToImpress(SfxRequest const & rRequest)
 242 {
 243     const SfxItemSet* pSet = rRequest.GetArgs();
 244
 245     if (pSet)
 246     {
 247         SvLockBytes* pBytes = static_cast<const SfxLockBytesItem&>(pSet->Get(SID_OUTLINE_TO_IMPRESS)).GetValue();
 248
 249         if (pBytes)
 250         {
 251             SfxObjectShellLock xDocShell;
 252             ::sd::DrawDocShell* pDocSh;
 253             xDocShell = pDocSh = new ::sd::DrawDocShell(
 254                 SfxObjectCreateMode::STANDARD, false, DocumentType::Impress);
 255
 256             pDocSh->DoInitNew();
 257             SdDrawDocument* pDoc = pDocSh->GetDoc();
 258             if(pDoc)
 259             {
 260                 pDoc->CreateFirstPages();
 261                 pDoc->StopWorkStartupDelay();
 262             }
 263
 264             const SfxFrameItem* pFrmItem = rRequest.GetArg<SfxFrameItem>(SID_DOCFRAME);
 265             SfxViewFrame::LoadDocumentIntoFrame( *pDocSh, pFrmItem, ::sd::OUTLINE_FACTORY_ID );
 266
 267             ::sd::ViewShell* pViewSh = pDocSh->GetViewShell();
 268
 269             if (pViewSh && pDoc)
 270             {
 271                 // AutoLayouts have to be finished
 272                 pDoc->StopWorkStartupDelay();
 273
 274                 SfxViewFrame* pViewFrame = pViewSh->GetViewFrame();
 275
 276                 // When the view frame has not been just created we have
 277                 // to switch synchronously to the outline view.
 278                 // (Otherwise the request will be ignored anyway.)
 279                 ::sd::ViewShellBase* pBase
 280                     = dynamic_cast< ::sd::ViewShellBase*>(pViewFrame->GetViewShell());
 281                 if (pBase != nullptr)
 282                 {
 283                     std::shared_ptr<FrameworkHelper> pHelper (
 284                         FrameworkHelper::Instance(*pBase));
 285                     pHelper->RequestView(
 286                         FrameworkHelper::msOutlineViewURL,
 287                         FrameworkHelper::msCenterPaneURL);
 288
 289                     pHelper->RunOnResourceActivation(
 290                         FrameworkHelper::CreateResourceId(
 291                         FrameworkHelper::msOutlineViewURL,
 292                         FrameworkHelper::msCenterPaneURL),
 293                         OutlineToImpressFinalizer(*pBase, *pDoc, *pBytes));
 294                 }
 295             }
 296         }
 297     }
 298
 299     return rRequest.IsDone();
 300 }
 301
 302 void SdModule::GetState(SfxItemSet& rItemSet)
 303 {
 304     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_METRIC ) )
 305     {
 306         ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 307         if(pDocSh)
 308         {
 309             DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
 310
 311             SdOptions* pOptions = GetSdOptions(eDocType);
 312             rItemSet.Put( SfxUInt16Item( SID_ATTR_METRIC, pOptions->GetMetric() ) );
 313         }
 314     }
 315
 316     // state of SID_OPENDOC is determined by the base class
 317     if (rItemSet.GetItemState(SID_OPENDOC) != SfxItemState::UNKNOWN)
 318     {
 319         const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENDOC, SfxGetpApp()->GetInterface());
 320         if (pItem)
 321             rItemSet.Put(*pItem);
 322     }
 323
 324     // state of SID_OPENHYPERLINK is determined by the base class
 325     if (rItemSet.GetItemState(SID_OPENHYPERLINK) != SfxItemState::UNKNOWN)
 326     {
 327         const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENHYPERLINK, SfxGetpApp()->GetInterface());
 328         if (pItem)
 329             rItemSet.Put(*pItem);
 330     }
 331
 332     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) )
 333     {
 334         ::sd::DrawDocShell* pDocSh =
 335               dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 336         if( pDocSh )
 337         {
 338             SdDrawDocument* pDoc = pDocSh->GetDoc();
 339             rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) );
 340         }
 341     }
 342
 343     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_LANGUAGE ) )
 344     {
 345         ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 346         if( pDocSh )
 347             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE ) );
 348     }
 349
 350     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE ) )
 351     {
 352         ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 353         if( pDocSh )
 354             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CJK ), SID_ATTR_CHAR_CJK_LANGUAGE ) );
 355     }
 356
 357     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE ) )
 358     {
 359         ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 360         if( pDocSh )
 361             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CTL ), SID_ATTR_CHAR_CTL_LANGUAGE ) );
 362     }
 363
 364     if ( mbEventListenerAdded )
 365         return;
 366
 367     ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 368     if( pDocShell ) // Impress or Draw ?
 369     {
 370         ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 371
 372         if( pViewShell && (pDocShell->GetDocumentType() == DocumentType::Impress) )
 373         {
 374             // add our event listener as soon as possible
 375             Application::AddEventListener( LINK( this, SdModule, EventListenerHdl ) );
 376             mbEventListenerAdded = true;
 377         }
 378     }
 379 }
 380
 381 IMPL_STATIC_LINK( SdModule, EventListenerHdl, VclSimpleEvent&, rSimpleEvent, void )
 382 {
 383     if( !((rSimpleEvent.GetId() == VclEventId::WindowCommand) && static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData()) )
 384         return;
 385
 386     const CommandEvent& rEvent = *static_cast<const CommandEvent*>(static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData());
 387
 388     if( rEvent.GetCommand() != CommandEventId::Media )
 389         return;
 390
 391     CommandMediaData* pMediaData = rEvent.GetMediaData();
 392     pMediaData->SetPassThroughToOS(false);
 393     switch (pMediaData->GetMediaId())
 394     {
 395         case MediaCommand::Play:
 396         {
 397             ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 398             if( pDocShell )  // Impress or Draw ?
 399             {
 400                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 401
 402                 // #i97925# start the presentation if and only if an Impress document is focused
 403                 if( pViewShell && (pDocShell->GetDocumentType() == DocumentType::Impress) )
 404                     pViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION );
 405             }
 406             break;
 407         }
 408         default:
 409             pMediaData->SetPassThroughToOS(true);
 410             break;
 411     }
 412 }
 413
 414
 415 SfxFrame* SdModule::CreateFromTemplate(const OUString& rTemplatePath, const Reference<XFrame>& i_rFrame,
 416                                        const bool bReplaceable)
 417 {
 418     SfxFrame* pFrame = nullptr;
 419
 420     SfxObjectShellLock xDocShell;
 421
 422     std::unique_ptr<SfxItemSet> pSet(new SfxAllItemSet( SfxGetpApp()->GetPool() ));
 423     pSet->Put( SfxBoolItem( SID_TEMPLATE, true ) );
 424
 425     ErrCode lErr = SfxGetpApp()->LoadTemplate( xDocShell, rTemplatePath, std::move(pSet) );
 426
 427     SfxObjectShell* pDocShell = xDocShell;
 428
 429     if( lErr )
 430     {
 431         ErrorHandler::HandleError(lErr);
 432     }
 433     else if( pDocShell )
 434     {
 435         if (pDocShell->GetMedium() && pDocShell->GetMedium()->GetItemSet())
 436             pDocShell->GetMedium()->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, bReplaceable));
 437         SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pDocShell, i_rFrame );
 438         OSL_ENSURE( pViewFrame, "SdModule::CreateFromTemplate: no view frame - was the document really loaded?" );
 439         pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
 440     }
 441
 442     return pFrame;
 443
 444 }
 445
 446 SfxFrame* SdModule::ExecuteNewDocument( SfxRequest const & rReq )
 447 {
 448     SfxFrame* pFrame = nullptr;
 449     if ( SvtModuleOptions().IsImpress() )
 450     {
 451         Reference< XFrame > xTargetFrame;
 452         const SfxUnoFrameItem* pFrmItem = rReq.GetArg<SfxUnoFrameItem>(SID_FILLFRAME);
 453         if ( pFrmItem )
 454             xTargetFrame = pFrmItem->GetFrame();
 455
 456         SdOptions* pOpt = GetSdOptions(DocumentType::Impress);
 457         bool bStartWithTemplate = pOpt->IsStartWithTemplate();
 458
 459         bool bNewDocDirect = rReq.GetSlot() == SID_NEWSD;
 460
 461         if( bNewDocDirect )
 462         {
 463             //we start without wizard
 464
 465             //check whether we should load a template document
 466             OUString aStandardTemplate( SfxObjectFactory::GetStandardTemplate( "com.sun.star.presentation.PresentationDocument" ) );
 467
 468             if( !aStandardTemplate.isEmpty() )
 469             {
 470                 //load a template document
 471                 pFrame = CreateFromTemplate(aStandardTemplate, xTargetFrame, true);
 472             }
 473             else
 474             {
 475                 //create an empty document
 476                 pFrame = CreateEmptyDocument( xTargetFrame );
 477             }
 478         }
 479
 480         if(bStartWithTemplate)
 481         {
 482             //Launch TemplateSelectionDialog
 483             vcl::Window* pTopLevel = SfxGetpApp()->GetTopWindow();
 484             SfxTemplateSelectionDlg aTemplDlg(pTopLevel ? pTopLevel->GetFrameWeld() : nullptr);
 485             aTemplDlg.run();
 486
 487             //check to disable the dialog
 488             pOpt->SetStartWithTemplate( aTemplDlg.IsStartWithTemplate() );
 489
 490             //pFrame is loaded with the desired template
 491             if (!aTemplDlg.getTemplatePath().isEmpty())
 492                 pFrame = CreateFromTemplate(aTemplDlg.getTemplatePath(), xTargetFrame, false);
 493         }
 494     }
 495
 496     return pFrame;
 497 }
 498
 499 SfxFrame* SdModule::CreateEmptyDocument( const Reference< XFrame >& i_rFrame )
 500 {
 501     SfxFrame* pFrame = nullptr;
 502
 503     SfxObjectShellLock xDocShell;
 504     ::sd::DrawDocShell* pNewDocSh;
 505     xDocShell = pNewDocSh = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD,false,DocumentType::Impress);
 506     pNewDocSh->DoInitNew();
 507     SdDrawDocument* pDoc = pNewDocSh->GetDoc();
 508     if (pDoc)
 509     {
 510         pDoc->CreateFirstPages();
 511         pDoc->StopWorkStartupDelay();
 512     }
 513     if (pNewDocSh->GetMedium() && pNewDocSh->GetMedium()->GetItemSet())
 514         pNewDocSh->GetMedium()->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, true));
 515
 516     SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pNewDocSh, i_rFrame );
 517     OSL_ENSURE( pViewFrame, "SdModule::CreateEmptyDocument: no view frame - was the document really loaded?" );
 518     pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
 519
 520     return pFrame;
 521 }
 522
 523 //===== OutlineToImpressFinalize ==============================================
 524
 525 namespace {
 526
 527 OutlineToImpressFinalizer::OutlineToImpressFinalizer (
 528     ::sd::ViewShellBase& rBase,
 529     SdDrawDocument& rDocument,
 530     SvLockBytes const & rBytes)
 531     : mrBase(rBase),
 532       mrDocument(rDocument),
 533       mpStream()
 534 {
 535     // The given stream has a lifetime shorter than this new
 536     // OutlineToImpressFinalizer object.  Therefore a local copy of the
 537     // stream is created.
 538     const SvStream* pStream (rBytes.GetStream());
 539     if (pStream == nullptr)
 540         return;
 541
 542     // Create a memory stream and prepare to fill it with the content of
 543     // the original stream.
 544     mpStream = std::make_shared<SvMemoryStream>();
 545     static const std::size_t nBufferSize = 4096;
 546     ::std::unique_ptr<sal_Int8[]> pBuffer (new sal_Int8[nBufferSize]);
 547
 548     sal_uInt64 nReadPosition(0);
 549     bool bLoop (true);
 550     while (bLoop)
 551     {
 552         // Read the next part of the original stream.
 553         std::size_t nReadByteCount (0);
 554         const ErrCode nErrorCode (
 555             rBytes.ReadAt(
 556                 nReadPosition,
 557                 pBuffer.get(),
 558                 nBufferSize,
 559                 &nReadByteCount));
 560
 561         // Check the error code and stop copying the stream data when an
 562         // error has occurred.
 563         if (nErrorCode == ERRCODE_NONE)
 564         {
 565             if (nReadByteCount == 0)
 566                 bLoop = false;
 567         }
 568         else if (nErrorCode == ERRCODE_IO_PENDING)
 569             ;
 570         else
 571         {
 572             bLoop = false;
 573             nReadByteCount = 0;
 574         }
 575
 576         // Append the read bytes to the end of the memory stream.
 577         if (nReadByteCount > 0)
 578         {
 579             mpStream->WriteBytes(pBuffer.get(), nReadByteCount);
 580             nReadPosition += nReadByteCount;
 581         }
 582     }
 583
 584     // Rewind the memory stream so that in the operator() method its
 585     // content is properly read.
 586     mpStream->Seek(STREAM_SEEK_TO_BEGIN);
 587 }
 588
 589 void OutlineToImpressFinalizer::operator() (bool)
 590 {
 591     // Fetch the new outline view shell.
 592     ::sd::OutlineViewShell* pOutlineShell
 593         = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get());
 594
 595     if (pOutlineShell != nullptr && mpStream != nullptr)
 596     {
 597         sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView());
 598         // mba: the stream can't contain any relative URLs, because we don't
 599         // have any information about a BaseURL!
 600         pOutlineShell->ReadRtf(*mpStream);
 601
 602         // Call UpdatePreview once for every slide to resync the
 603         // document with the outliner of the OutlineViewShell.
 604         sal_uInt16 nPageCount (mrDocument.GetSdPageCount(PageKind::Standard));
 605         for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++)
 606         {
 607             SdPage* pPage = mrDocument.GetSdPage(nIndex, PageKind::Standard);
 608             // Make the page the actual page so that the
 609             // following UpdatePreview() call accesses the
 610             // correct paragraphs.
 611             pView->SetActualPage(pPage);
 612             pOutlineShell->UpdatePreview(pPage);
 613         }
 614         // Select the first slide.
 615         SdPage* pPage = mrDocument.GetSdPage(0, PageKind::Standard);
 616         pView->SetActualPage(pPage);
 617         pOutlineShell->UpdatePreview(pPage);
 618     }
 619
 620     // Undo-Stack needs to be cleared, else the user may remove the
 621     // only drawpage and this is a state we cannot handle ATM.
 622     ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh();
 623     if( pDocShell )
 624         pDocShell->ClearUndoBuffer();
 625 }
 626
 627 } // end of anonymous namespace
 628
 629 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */