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