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
  28 #include <editeng/langitem.hxx>
  29 #include <editeng/editdata.hxx>
  30 #include <vcl/msgbox.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 <editeng/paperinf.hxx>
  37 #include <editeng/eeitem.hxx>
  38 #include <unotools/useroptions.hxx>
  39 #include <com/sun/star/uno/Sequence.h>
  40
  41 #include "app.hrc"
  42 #include "glob.hrc"
  43 #include "strings.hrc"
  44 #include "res_bmp.hrc"
  45
  46 #include "sdmod.hxx"
  47 #include "pres.hxx"
  48 #include "optsitem.hxx"
  49 #include "ViewShell.hxx"
  50 #include "sdattr.hxx"
  51 #include "sdpage.hxx"
  52 #include "DrawDocShell.hxx"
  53 #include "drawdoc.hxx"
  54 #include "assclass.hxx"
  55 #include "sdenumdef.hxx"
  56 #include "sdresid.hxx"
  57 #include "OutlineViewShell.hxx"
  58 #include "ViewShellBase.hxx"
  59 #include "FrameView.hxx"
  60 #include "FactoryIds.hxx"
  61 #include "sdabstdlg.hxx"
  62 #include <boost/shared_ptr.hpp>
  63 #include <boost/scoped_array.hpp>
  64 #include "slideshow.hxx"
  65
  66 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  67 #include <com/sun/star/document/XDocumentProperties.hpp>
  68
  69 using ::sd::framework::FrameworkHelper;
  70 using ::com::sun::star::uno::Reference;
  71 using ::com::sun::star::frame::XFrame;
  72 using ::com::sun::star::uno::Sequence;
  73
  74 namespace {
  75
  76 class OutlineToImpressFinalizer
  77 {
  78 public:
  79     OutlineToImpressFinalizer (
  80         ::sd::ViewShellBase& rBase,
  81         SdDrawDocument& rDocument,
  82         SvLockBytes& rBytes);
  83     virtual ~OutlineToImpressFinalizer() {};
  84     void operator() (bool bEventSeen);
  85 private:
  86     ::sd::ViewShellBase& mrBase;
  87     SdDrawDocument& mrDocument;
  88     ::boost::shared_ptr<SvMemoryStream> mpStream;
  89 };
  90
  91 } //end of anonymous namespace
  92
  93 void SdModule::Execute(SfxRequest& rReq)
  94 {
  95     const SfxItemSet* pSet = rReq.GetArgs();
  96     sal_uLong nSlotId = rReq.GetSlot();
  97
  98     switch ( nSlotId )
  99     {
 100         case SID_NEWDOC:
 101         {
 102             SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
 103         }
 104         break;
 105
 106         case SID_AUTOSPELL_CHECK:
 107         {
 108             // automatic spell checker
 109             const SfxPoolItem* pItem;
 110             if( pSet && SfxItemState::SET == pSet->GetItemState(
 111                         SID_AUTOSPELL_CHECK, false, &pItem ) )
 112             {
 113                 bool bOnlineSpelling = static_cast<const SfxBoolItem*>( pItem )->GetValue();
 114                 // save at document:
 115                 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 116                 if( pDocSh )
 117                 {
 118                     SdDrawDocument* pDoc = pDocSh->GetDoc();
 119                     pDoc->SetOnlineSpell( bOnlineSpelling );
 120                 }
 121             }
 122         }
 123         break;
 124
 125         case SID_ATTR_METRIC:
 126         {
 127             const SfxPoolItem* pItem;
 128             if ( pSet && SfxItemState::SET == pSet->GetItemState( SID_ATTR_METRIC, true, &pItem ) )
 129             {
 130                 FieldUnit eUnit = (FieldUnit)static_cast<const SfxUInt16Item*>(pItem)->GetValue();
 131                 switch( eUnit )
 132                 {
 133                     case FUNIT_MM:      // only the units which are also in the dialog
 134                     case FUNIT_CM:
 135                     case FUNIT_INCH:
 136                     case FUNIT_PICA:
 137                     case FUNIT_POINT:
 138                         {
 139                             ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 140                             if(pDocSh)
 141                             {
 142                                 DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
 143
 144                                 PutItem( *pItem );
 145                                 SdOptions* pOptions = GetSdOptions( eDocType );
 146                                 if(pOptions)
 147                                     pOptions->SetMetric( (sal_uInt16)eUnit );
 148                                 rReq.Done();
 149                             }
 150                         }
 151                         break;
 152                     default:
 153                         break;
 154                     }
 155                 }
 156
 157         }
 158         break;
 159
 160         case SID_ATTR_LANGUAGE:
 161         case SID_ATTR_CHAR_CJK_LANGUAGE:
 162         case SID_ATTR_CHAR_CTL_LANGUAGE:
 163         {
 164             const SfxPoolItem* pItem;
 165             if( pSet &&
 166                 (
 167                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_LANGUAGE, false, &pItem ) ||
 168                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CJK_LANGUAGE, false, &pItem ) ||
 169                 SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CTL_LANGUAGE, false, &pItem )
 170                 )
 171               )
 172             {
 173                 // save at the document:
 174                 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 175                 if ( pDocSh )
 176                 {
 177                     LanguageType eLanguage = static_cast<const SvxLanguageItem*>(pItem)->GetValue();
 178                     SdDrawDocument* pDoc = pDocSh->GetDoc();
 179
 180                     if( nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE )
 181                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CJK );
 182                     else if( nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE )
 183                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CTL );
 184                     else
 185                         pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE );
 186
 187                     if( pDoc->GetOnlineSpell() )
 188                     {
 189                         pDoc->StopOnlineSpelling();
 190                         pDoc->StartOnlineSpelling();
 191                     }
 192                 }
 193             }
 194         }
 195         break;
 196
 197         case SID_SD_AUTOPILOT:
 198         case SID_NEWSD:
 199             {
 200                 SfxFrame* pFrame = ExecuteNewDocument( rReq );
 201                 // if a frame was created, set it as return value
 202                 if(pFrame)
 203                     rReq.SetReturnValue(SfxFrameItem(0, pFrame));
 204             }
 205
 206             break;
 207
 208         case SID_OPENHYPERLINK:
 209         case SID_OPENDOC:
 210         {
 211             bool bIntercept = false;
 212             ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 213             if (pDocShell)
 214             {
 215                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 216                 if (pViewShell)
 217                 {
 218                     if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
 219                     {
 220                         // Prevent documents from opening while the slide
 221                         // show is running, except when this request comes
 222                         // from a shape interaction.
 223                         if (rReq.GetArgs() == NULL)
 224                         {
 225                             bIntercept = true;
 226                         }
 227                     }
 228                 }
 229             }
 230
 231             if (!bIntercept)
 232             {
 233                 SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
 234             }
 235             else
 236             {
 237                 ScopedVclPtrInstance<MessageDialog>::Create(nullptr, SD_RESSTR(STR_CANT_PERFORM_IN_LIVEMODE))->Execute();
 238
 239                 SFX_REQUEST_ARG( rReq, pLinkItem, SfxLinkItem, SID_DONELINK, false );
 240                 if( pLinkItem )
 241                     pLinkItem->GetValue().Call( 0 );
 242             }
 243         }
 244         break;
 245
 246         case SID_OUTLINE_TO_IMPRESS:
 247             OutlineToImpress (rReq);
 248             break;
 249
 250         default:
 251         break;
 252     }
 253 }
 254
 255 bool SdModule::OutlineToImpress(SfxRequest& rRequest)
 256 {
 257     const SfxItemSet* pSet = rRequest.GetArgs();
 258
 259     if (pSet)
 260     {
 261         SvLockBytes* pBytes = static_cast<const SfxLockBytesItem&>(pSet->Get(SID_OUTLINE_TO_IMPRESS)).GetValue();
 262
 263         if (pBytes)
 264         {
 265             SfxObjectShellLock xDocShell;
 266             ::sd::DrawDocShell* pDocSh;
 267             xDocShell = pDocSh = new ::sd::DrawDocShell(
 268                 SfxObjectCreateMode::STANDARD, false);
 269
 270             pDocSh->DoInitNew(NULL);
 271             SdDrawDocument* pDoc = pDocSh->GetDoc();
 272             if(pDoc)
 273             {
 274                 pDoc->CreateFirstPages();
 275                 pDoc->StopWorkStartupDelay();
 276             }
 277
 278             SFX_REQUEST_ARG( rRequest, pFrmItem, SfxFrameItem, SID_DOCFRAME, false);
 279             SfxViewFrame::LoadDocumentIntoFrame( *pDocSh, pFrmItem, ::sd::OUTLINE_FACTORY_ID );
 280
 281             ::sd::ViewShell* pViewSh = pDocSh->GetViewShell();
 282
 283             if (pViewSh && pDoc)
 284             {
 285                 // AutoLayouts have to be finished
 286                 pDoc->StopWorkStartupDelay();
 287
 288                 SfxViewFrame* pViewFrame = pViewSh->GetViewFrame();
 289
 290                 // When the view frame has not been just created we have
 291                 // to switch synchronously to the outline view.
 292                 // (Otherwise the request will be ignored anyway.)
 293                 ::sd::ViewShellBase* pBase
 294                     = dynamic_cast< ::sd::ViewShellBase*>(pViewFrame->GetViewShell());
 295                 if (pBase != NULL)
 296                 {
 297                     ::boost::shared_ptr<FrameworkHelper> pHelper (
 298                         FrameworkHelper::Instance(*pBase));
 299                     pHelper->RequestView(
 300                         FrameworkHelper::msOutlineViewURL,
 301                         FrameworkHelper::msCenterPaneURL);
 302
 303                     pHelper->RunOnResourceActivation(
 304                         FrameworkHelper::CreateResourceId(
 305                         FrameworkHelper::msOutlineViewURL,
 306                         FrameworkHelper::msCenterPaneURL),
 307                         OutlineToImpressFinalizer(*pBase, *pDoc, *pBytes));
 308                 }
 309             }
 310         }
 311     }
 312
 313     return rRequest.IsDone();
 314 }
 315
 316 void SdModule::GetState(SfxItemSet& rItemSet)
 317 {
 318     // disable Autopilot during presentation
 319     if (rItemSet.GetItemState(SID_SD_AUTOPILOT) != SfxItemState::UNKNOWN)
 320     {
 321         if (!SvtModuleOptions().IsImpress())
 322         {
 323             rItemSet.DisableItem(SID_SD_AUTOPILOT);
 324         }
 325         else
 326         {
 327             ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 328             if (pDocShell)
 329             {
 330                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 331                 if (pViewShell)
 332                 {
 333                     if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
 334                     {
 335                         rItemSet.DisableItem(SID_SD_AUTOPILOT);
 336                     }
 337                 }
 338             }
 339         }
 340     }
 341
 342     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_METRIC ) )
 343     {
 344         ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 345         if(pDocSh)
 346         {
 347             DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
 348
 349             SdOptions* pOptions = GetSdOptions(eDocType);
 350             rItemSet.Put( SfxUInt16Item( SID_ATTR_METRIC, pOptions->GetMetric() ) );
 351         }
 352     }
 353
 354     // state of SID_OPENDOC is determined by the base class
 355     if (rItemSet.GetItemState(SID_OPENDOC) != SfxItemState::UNKNOWN)
 356     {
 357         const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENDOC, SfxGetpApp()->GetInterface());
 358         if (pItem)
 359             rItemSet.Put(*pItem);
 360     }
 361
 362     // state of SID_OPENHYPERLINK is determined by the base class
 363     if (rItemSet.GetItemState(SID_OPENHYPERLINK) != SfxItemState::UNKNOWN)
 364     {
 365         const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENHYPERLINK, SfxGetpApp()->GetInterface());
 366         if (pItem)
 367             rItemSet.Put(*pItem);
 368     }
 369
 370     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) )
 371     {
 372         ::sd::DrawDocShell* pDocSh =
 373               PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 374         if( pDocSh )
 375         {
 376             SdDrawDocument* pDoc = pDocSh->GetDoc();
 377             rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) );
 378         }
 379     }
 380
 381     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_LANGUAGE ) )
 382     {
 383         ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 384         if( pDocSh )
 385             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE ) );
 386     }
 387
 388     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE ) )
 389     {
 390         ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 391         if( pDocSh )
 392             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CJK ), SID_ATTR_CHAR_CJK_LANGUAGE ) );
 393     }
 394
 395     if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE ) )
 396     {
 397         ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 398         if( pDocSh )
 399             rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CTL ), SID_ATTR_CHAR_CTL_LANGUAGE ) );
 400     }
 401
 402     if ( !mbEventListenerAdded )
 403     {
 404         ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 405         if( pDocShell ) // Impress or Draw ?
 406         {
 407             ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 408
 409             if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) )
 410             {
 411                 // add our event listener as soon as possible
 412                 Application::AddEventListener( LINK( this, SdModule, EventListenerHdl ) );
 413                 mbEventListenerAdded = true;
 414             }
 415         }
 416     }
 417 }
 418
 419 IMPL_STATIC_LINK( SdModule, EventListenerHdl, VclSimpleEvent*, pEvent )
 420 {
 421     if( pEvent && (pEvent->GetId() == VCLEVENT_WINDOW_COMMAND) && static_cast<VclWindowEvent*>(pEvent)->GetData() )
 422     {
 423         const CommandEvent& rEvent = *static_cast<const CommandEvent*>(static_cast<VclWindowEvent*>(pEvent)->GetData());
 424
 425         if( rEvent.GetCommand() == CommandEventId::Media )
 426         {
 427             CommandMediaData* pMediaData = rEvent.GetMediaData();
 428             pMediaData->SetPassThroughToOS(false);
 429             switch (pMediaData->GetMediaId())
 430             {
 431                 case MediaCommand::Play:
 432                 {
 433                     ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
 434                     if( pDocShell )  // Impress or Draw ?
 435                     {
 436                         ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 437
 438                         // #i97925# start the presentation if and only if an Impress document is focused
 439                         if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) )
 440                             pViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION );
 441                     }
 442                     break;
 443                 }
 444                 default:
 445                     pMediaData->SetPassThroughToOS(true);
 446                     break;
 447             }
 448         }
 449     }
 450     return 0;
 451 }
 452
 453 void SdModule::AddSummaryPage (SfxViewFrame* pViewFrame, SdDrawDocument* pDocument)
 454 {
 455     if( !pViewFrame || !pViewFrame->GetDispatcher() || !pDocument )
 456         return;
 457
 458     pViewFrame->GetDispatcher()->Execute(SID_SUMMARY_PAGE,
 459         SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
 460
 461     OSL_ASSERT (pDocument!=NULL);
 462
 463     sal_Int32 nPageCount = pDocument->GetSdPageCount (PK_STANDARD);
 464
 465     // We need at least two pages: the summary page and one to use as
 466     // template to take the transition parameters from.
 467     if (nPageCount >= 2)
 468     {
 469         // Get a page from which to retrieve the transition parameters.
 470         SdPage* pTemplatePage = pDocument->GetSdPage (0, PK_STANDARD);
 471         OSL_ASSERT (pTemplatePage!=NULL);
 472
 473         // The summary page, if it exists, is the last page.
 474         SdPage* pSummaryPage = pDocument->GetSdPage (
 475             (sal_uInt16)nPageCount-1, PK_STANDARD);
 476         OSL_ASSERT (pSummaryPage!=NULL);
 477
 478         // Take the change mode of the template page as indication of the
 479         // document's kiosk mode.
 480         pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration());
 481         pSummaryPage->SetPresChange(pTemplatePage->GetPresChange());
 482         pSummaryPage->SetTime(pTemplatePage->GetTime());
 483         pSummaryPage->SetSound(pTemplatePage->IsSoundOn());
 484         pSummaryPage->SetSoundFile(pTemplatePage->GetSoundFile());
 485         pSummaryPage->setTransitionType(pTemplatePage->getTransitionType());
 486         pSummaryPage->setTransitionSubtype(pTemplatePage->getTransitionSubtype());
 487         pSummaryPage->setTransitionDirection(pTemplatePage->getTransitionDirection());
 488         pSummaryPage->setTransitionFadeColor(pTemplatePage->getTransitionFadeColor());
 489         pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration());
 490     }
 491 }
 492
 493 SfxFrame* SdModule::CreateFromTemplate( const OUString& rTemplatePath, const Reference< XFrame >& i_rFrame )
 494 {
 495     SfxFrame* pFrame = 0;
 496
 497     SfxObjectShellLock xDocShell;
 498
 499     SfxItemSet* pSet = new SfxAllItemSet( SfxGetpApp()->GetPool() );
 500     pSet->Put( SfxBoolItem( SID_TEMPLATE, true ) );
 501
 502     sal_uLong lErr = SfxGetpApp()->LoadTemplate( xDocShell, rTemplatePath, true, pSet );
 503
 504     SfxObjectShell* pDocShell = xDocShell;
 505
 506     if( lErr )
 507     {
 508         ErrorHandler::HandleError(lErr);
 509     }
 510     else if( pDocShell )
 511     {
 512         SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pDocShell, i_rFrame );
 513         OSL_ENSURE( pViewFrame, "SdModule::CreateFromTemplate: no view frame - was the document really loaded?" );
 514         pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
 515     }
 516
 517     return pFrame;
 518
 519 }
 520
 521 SfxFrame* SdModule::ExecuteNewDocument( SfxRequest& rReq )
 522 {
 523     SfxFrame* pFrame = 0;
 524     if ( SvtModuleOptions().IsImpress() )
 525     {
 526         Reference< XFrame > xTargetFrame;
 527         SFX_REQUEST_ARG( rReq, pFrmItem, SfxUnoFrameItem, SID_FILLFRAME, false);
 528         if ( pFrmItem )
 529             xTargetFrame = pFrmItem->GetFrame();
 530
 531         SfxViewFrame* pViewFrame = NULL;
 532
 533         SdOptions* pOpt = GetSdOptions(DOCUMENT_TYPE_IMPRESS);
 534         bool bStartWithTemplate = pOpt->IsStartWithTemplate();
 535
 536         bool bNewDocDirect = rReq.GetSlot() == SID_NEWSD;
 537         if( bNewDocDirect && !bStartWithTemplate )
 538         {
 539             //we start without wizard
 540
 541             //check whether we should load a template document
 542             const OUString aServiceName( "com.sun.star.presentation.PresentationDocument" );
 543             OUString aStandardTemplate( SfxObjectFactory::GetStandardTemplate( aServiceName ) );
 544
 545             if( !aStandardTemplate.isEmpty() )
 546             {
 547                 //load a template document
 548                 pFrame = CreateFromTemplate( aStandardTemplate, xTargetFrame );
 549             }
 550             else
 551             {
 552                 //create an empty document
 553                 pFrame = CreateEmptyDocument( DOCUMENT_TYPE_IMPRESS, xTargetFrame );
 554             }
 555         }
 556         else
 557         {
 558             SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 559             boost::scoped_ptr< AbstractAssistentDlg > pPilotDlg( pFact ? pFact->CreateAssistentDlg( NULL, !bNewDocDirect ) : 0 );
 560
 561             // Open the Pilot
 562             if( pPilotDlg.get() && pPilotDlg->Execute()==RET_OK )
 563             {
 564                 const OUString aDocPath( pPilotDlg->GetDocPath());
 565                 const bool bIsDocEmpty = pPilotDlg->IsDocEmpty();
 566
 567                 // So that you can open the document without AutoLayout-Dialog
 568                 pOpt->SetStartWithTemplate(false);
 569                 if(bNewDocDirect && !pPilotDlg->GetStartWithFlag())
 570                     bStartWithTemplate = false;
 571
 572                 if( pPilotDlg->GetStartType() == ST_OPEN )
 573                 {
 574                     OUString aFileToOpen = aDocPath;
 575
 576                     DBG_ASSERT( !aFileToOpen.isEmpty(), "The autopilot should have asked for a file itself already!" );
 577                     if (!aFileToOpen.isEmpty())
 578                     {
 579                         com::sun::star::uno::Sequence< com::sun::star::beans::NamedValue > aPasswrd( pPilotDlg->GetPassword() );
 580
 581                         SfxStringItem aFile( SID_FILE_NAME, aFileToOpen );
 582                         SfxStringItem aReferer( SID_REFERER, OUString());
 583                         SfxUnoAnyItem aPassword( SID_ENCRYPTIONDATA, com::sun::star::uno::makeAny(aPasswrd) );
 584
 585                         if ( xTargetFrame.is() )
 586                         {
 587                             SfxAllItemSet aSet( *rReq.GetArgs()->GetPool() );
 588                             aSet.Put( aFile );
 589                             aSet.Put( aReferer );
 590                             // Put the password into the request
 591                             // only if it is not empty.
 592                             if (aPasswrd.getLength() > 0)
 593                                 aSet.Put( aPassword );
 594
 595                             const SfxPoolItem* pRet = SfxFrame::OpenDocumentSynchron( aSet, xTargetFrame );
 596                             const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet );
 597                             if ( pFrameItem && pFrameItem->GetFrame() )
 598                                 pFrame = &pFrameItem->GetFrame()->GetFrame();
 599                         }
 600                         else
 601                         {
 602                             SfxRequest aRequest (SID_OPENDOC, SfxCallMode::SYNCHRON, SfxGetpApp()->GetPool());
 603                             aRequest.AppendItem (aFile);
 604                             aRequest.AppendItem (aReferer);
 605                             // Put the password into the request
 606                             // only if it is not empty.
 607                             if (aPasswrd.getLength() > 0)
 608                                 aRequest.AppendItem (aPassword);
 609                             aRequest.AppendItem (SfxStringItem (
 610                                 SID_TARGETNAME,
 611                                 OUString("_default")));
 612                             try
 613                             {
 614                                 const SfxPoolItem* pRet = SfxGetpApp()->ExecuteSlot (aRequest);
 615                                 const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet );
 616                                 if ( pFrameItem )
 617                                     pFrame = &pFrameItem->GetFrame()->GetFrame();
 618                             }
 619                             catch (const ::com::sun::star::uno::Exception&)
 620                             {
 621                                 DBG_ASSERT (false, "caught IllegalArgumentException while loading document from Impress autopilot");
 622                             }
 623                         }
 624                     }
 625
 626                     pOpt->SetStartWithTemplate(bStartWithTemplate);
 627                     if(bNewDocDirect && !bStartWithTemplate)
 628                     {
 629                         boost::scoped_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) );
 630                         if(pRet.get())
 631                             ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() );
 632
 633                     }
 634                 }
 635                 else
 636                 {
 637                     SfxObjectShellLock xShell( pPilotDlg->GetDocument() );
 638                     SfxObjectShell* pShell = xShell;
 639                     if( pShell )
 640                     {
 641                         pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pShell, xTargetFrame );
 642                         DBG_ASSERT( pViewFrame, "no ViewFrame!!" );
 643                         pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
 644
 645                         if(bNewDocDirect && !bStartWithTemplate)
 646                         {
 647                             boost::scoped_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) );
 648                             if(pRet.get())
 649                                 ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() );
 650                         }
 651
 652                         ::sd::DrawDocShell* pDocShell(NULL);
 653                         ::sd::ViewShellBase* pBase(NULL);
 654                         SdDrawDocument* pDoc(NULL);
 655                         if (pShell && pViewFrame)
 656                         {
 657                             pDocShell = PTR_CAST(::sd::DrawDocShell, pShell);
 658                             pDoc = pDocShell ? pDocShell->GetDoc() : NULL;
 659                             pBase = ::sd::ViewShellBase::GetViewShellBase(pViewFrame);
 660                         }
 661
 662                         if (pDoc && pBase)
 663                         {
 664                             ::boost::shared_ptr<sd::ViewShell> pViewSh = pBase->GetMainViewShell();
 665                             SdOptions* pOptions = GetSdOptions(pDoc->GetDocumentType());
 666
 667                             if (pOptions && pViewSh.get())
 668                             {
 669                                 // The AutoPilot-document shall be open without its own options
 670                                 ::sd::FrameView* pFrameView = pViewSh->GetFrameView();
 671                                 pFrameView->Update(pOptions);
 672                                 pViewSh->ReadFrameViewData(pFrameView);
 673                             }
 674
 675                             ChangeMedium( pDocShell, pViewFrame, pPilotDlg->GetOutputMedium() );
 676
 677                             if(pPilotDlg->IsSummary())
 678                                 AddSummaryPage(pViewFrame, pDoc);
 679
 680                             // empty document
 681                             if (aDocPath.isEmpty() && pViewFrame && pViewFrame->GetDispatcher())
 682                             {
 683                                 SfxBoolItem aIsChangedItem(SID_MODIFYPAGE, !bIsDocEmpty);
 684                                 SfxUInt32Item eAutoLayout( ID_VAL_WHATLAYOUT, (sal_uInt32) AUTOLAYOUT_TITLE );
 685                                 pViewFrame->GetDispatcher()->Execute(SID_MODIFYPAGE,
 686                                    SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aIsChangedItem, &eAutoLayout, 0L);
 687                             }
 688
 689                             // clear document info
 690                             using namespace ::com::sun::star;
 691                             uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
 692                                 pDocShell->GetModel(), uno::UNO_QUERY_THROW);
 693                             uno::Reference<document::XDocumentProperties>
 694                                 xDocProps(xDPS->getDocumentProperties());
 695                             DBG_ASSERT(xDocProps.is(), "no DocumentProperties");
 696                             xDocProps->resetUserData(
 697                                 SvtUserOptions().GetFullName() );
 698                             xDocProps->setTemplateName(xDocProps->getTitle());
 699                             xDocProps->setTemplateURL(pPilotDlg->GetDocPath());
 700
 701                             pDoc->SetChanged(!bIsDocEmpty);
 702
 703                             pDocShell->SetUseUserData(true);
 704
 705                             // clear UNDO stack after autopilot
 706                             pDocShell->ClearUndoBuffer();
 707                         }
 708                     }
 709                     pOpt->SetStartWithTemplate(bStartWithTemplate);
 710                 }
 711             }
 712         }
 713     }
 714
 715     return pFrame;
 716 }
 717
 718 SfxFrame* SdModule::CreateEmptyDocument( DocumentType eDocType, const Reference< XFrame >& i_rFrame )
 719 {
 720     SfxFrame* pFrame = 0;
 721
 722     SfxObjectShellLock xDocShell;
 723     ::sd::DrawDocShell* pNewDocSh;
 724     xDocShell = pNewDocSh = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD,false,eDocType);
 725     pNewDocSh->DoInitNew(NULL);
 726     SdDrawDocument* pDoc = pNewDocSh->GetDoc();
 727     if (pDoc)
 728     {
 729         pDoc->CreateFirstPages();
 730         pDoc->StopWorkStartupDelay();
 731     }
 732
 733     SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pNewDocSh, i_rFrame );
 734     OSL_ENSURE( pViewFrame, "SdModule::CreateEmptyDocument: no view frame - was the document really loaded?" );
 735     pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
 736
 737     return pFrame;
 738 }
 739
 740 void SdModule::ChangeMedium( ::sd::DrawDocShell* pDocShell, SfxViewFrame* pViewFrame, const sal_Int32 eMedium )
 741 {
 742     if( !pDocShell )
 743         return;
 744
 745     SdDrawDocument* pDoc = pDocShell->GetDoc();
 746     if( !pDoc )
 747         return;
 748
 749     // settings for the Outputmedium
 750     Size aNewSize;
 751     sal_uInt32 nLeft = 0;
 752     sal_uInt32 nRight = 0;
 753     sal_uInt32 nLower = 0;
 754     sal_uInt32 nUpper = 0;
 755     switch(eMedium)
 756     {
 757         case OUTPUT_PAGE:
 758         case OUTPUT_OVERHEAD:
 759         {
 760             SfxPrinter* pPrinter = pDocShell->GetPrinter(true);
 761
 762             if( pPrinter && pPrinter->IsValid())
 763             {
 764                 // Unfortunately, the printer does not provide an exact format
 765                 // like A4
 766                 Size aSize(pPrinter->GetPaperSize());
 767                 Paper ePaper = SvxPaperInfo::GetSvxPaper( aSize, MAP_100TH_MM, true);
 768
 769                 if (ePaper != PAPER_USER)
 770                 {
 771                     // get correct size
 772                     aSize = SvxPaperInfo::GetPaperSize(ePaper, MAP_100TH_MM);
 773                 }
 774
 775                 if (aSize.Height() > aSize.Width())
 776                 {
 777                      // always landscape
 778                      aNewSize.Width()  = aSize.Height();
 779                      aNewSize.Height() = aSize.Width();
 780                 }
 781                 else
 782                 {
 783                      aNewSize = aSize;
 784                 }
 785             }
 786             else
 787             {
 788                 aNewSize=Size(29700, 21000);
 789             }
 790
 791             if (eMedium == OUTPUT_PAGE)
 792             {
 793                 nLeft =1000;
 794                 nRight=1000;
 795                 nUpper=1000;
 796                 nLower=1000;
 797             }
 798             else
 799             {
 800                 nLeft =0;
 801                 nRight=0;
 802                 nUpper=0;
 803                 nLower=0;
 804             }
 805         }
 806         break;
 807
 808         case OUTPUT_SLIDE:
 809         {
 810             aNewSize = Size(27000, 18000);
 811             nLeft =0;
 812             nRight=0;
 813             nUpper=0;
 814             nLower=0;
 815         }
 816         break;
 817
 818         case OUTPUT_WIDESCREEN:
 819         {
 820             aNewSize = Size(28000, 15750);
 821             nLeft =0;
 822             nRight=0;
 823             nUpper=0;
 824             nLower=0;
 825         }
 826         break;
 827
 828         case OUTPUT_PRESENTATION:
 829         {
 830             aNewSize = Size(28000, 21000);
 831             nLeft =0;
 832             nRight=0;
 833             nUpper=0;
 834             nLower=0;
 835         }
 836         break;
 837     }
 838
 839     bool bScaleAll = true;
 840     sal_uInt16 nPageCnt = pDoc->GetMasterSdPageCount(PK_STANDARD);
 841     sal_uInt16 i;
 842     SdPage* pPage;
 843
 844     // master pages first
 845     for (i = 0; i < nPageCnt; i++)
 846     {
 847         pPage = pDoc->GetMasterSdPage(i, PK_STANDARD);
 848
 849         if (pPage)
 850         {
 851             if(eMedium != OUTPUT_ORIGINAL)
 852             {
 853                 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 854                 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll);
 855                 pPage->SetSize(aNewSize);
 856                 pPage->SetBorder(nLeft, nUpper, nRight, nLower);
 857             }
 858             SdPage* pNotesPage = pDoc->GetMasterSdPage(i, PK_NOTES);
 859             DBG_ASSERT( pNotesPage, "Wrong page ordering!" );
 860             if( pNotesPage ) pNotesPage->CreateTitleAndLayout();
 861             pPage->CreateTitleAndLayout();
 862         }
 863     }
 864
 865     nPageCnt = pDoc->GetSdPageCount(PK_STANDARD);
 866
 867     // then slides
 868     for (i = 0; i < nPageCnt; i++)
 869     {
 870         pPage = pDoc->GetSdPage(i, PK_STANDARD);
 871
 872         if (pPage)
 873         {
 874             if(eMedium != OUTPUT_ORIGINAL)
 875             {
 876                 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 877                 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll);
 878                 pPage->SetSize(aNewSize);
 879                 pPage->SetBorder(nLeft, nUpper, nRight, nLower);
 880             }
 881             SdPage* pNotesPage = pDoc->GetSdPage(i, PK_NOTES);
 882             DBG_ASSERT( pNotesPage, "Wrong page ordering!" );
 883             if( pNotesPage ) pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
 884             pPage->SetAutoLayout( pPage->GetAutoLayout() );
 885         }
 886     }
 887
 888     SdPage* pHandoutPage = pDoc->GetSdPage(0, PK_HANDOUT);
 889     pHandoutPage->CreateTitleAndLayout(true);
 890
 891     if( (eMedium != OUTPUT_ORIGINAL) && pViewFrame && pViewFrame->GetDispatcher())
 892     {
 893         pViewFrame->GetDispatcher()->Execute(SID_SIZE_PAGE, SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
 894     }
 895 }
 896
 897 //===== OutlineToImpressFinalize ==============================================
 898
 899 namespace {
 900
 901 OutlineToImpressFinalizer::OutlineToImpressFinalizer (
 902     ::sd::ViewShellBase& rBase,
 903     SdDrawDocument& rDocument,
 904     SvLockBytes& rBytes)
 905     : mrBase(rBase),
 906       mrDocument(rDocument),
 907       mpStream()
 908 {
 909     // The given stream has a lifetime shorter than this new
 910     // OutlineToImpressFinalizer object.  Therefore a local copy of the
 911     // stream is created.
 912     const SvStream* pStream (rBytes.GetStream());
 913     if (pStream != NULL)
 914     {
 915         // Create a memory stream and prepare to fill it with the content of
 916         // the original stream.
 917         mpStream.reset(new SvMemoryStream());
 918         static const sal_Size nBufferSize = 4096;
 919         ::boost::scoped_array<sal_Int8> pBuffer (new sal_Int8[nBufferSize]);
 920
 921         sal_uInt64 nReadPosition(0);
 922         bool bLoop (true);
 923         while (bLoop)
 924         {
 925             // Read the next part of the original stream.
 926             sal_Size nReadByteCount (0);
 927             const ErrCode nErrorCode (
 928                 rBytes.ReadAt(
 929                     nReadPosition,
 930                     pBuffer.get(),
 931                     nBufferSize,
 932                     &nReadByteCount));
 933
 934             // Check the error code and stop copying the stream data when an
 935             // error has occurred.
 936             switch (nErrorCode)
 937             {
 938                 case ERRCODE_NONE:
 939                     if (nReadByteCount == 0)
 940                         bLoop = false;
 941                     break;
 942                 case ERRCODE_IO_PENDING:
 943                     break;
 944
 945                 default:
 946                     bLoop = false;
 947                     nReadByteCount = 0;
 948                     break;
 949             }
 950
 951             // Append the read bytes to the end of the memory stream.
 952             if (nReadByteCount > 0)
 953             {
 954                 mpStream->Write(pBuffer.get(), nReadByteCount);
 955                 nReadPosition += nReadByteCount;
 956             }
 957         }
 958
 959         // Rewind the memory stream so that in the operator() method its
 960         // content is properly read.
 961         mpStream->Seek(STREAM_SEEK_TO_BEGIN);
 962     }
 963 }
 964
 965 void OutlineToImpressFinalizer::operator() (bool)
 966 {
 967     // Fetch the new outline view shell.
 968     ::sd::OutlineViewShell* pOutlineShell
 969         = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get());
 970
 971     if (pOutlineShell != NULL && mpStream.get() != NULL)
 972     {
 973         sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView());
 974         // mba: the stream can't contain any relative URLs, because we don't
 975         // have any information about a BaseURL!
 976         if ( pOutlineShell->Read(*mpStream, OUString(), EE_FORMAT_RTF) == 0 )
 977         {
 978         }
 979
 980         // Call UpdatePreview once for every slide to resync the
 981         // document with the outliner of the OutlineViewShell.
 982         sal_uInt16 nPageCount (mrDocument.GetSdPageCount(PK_STANDARD));
 983         for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++)
 984         {
 985             SdPage* pPage = mrDocument.GetSdPage(nIndex, PK_STANDARD);
 986             // Make the page the actual page so that the
 987             // following UpdatePreview() call accesses the
 988             // correct paragraphs.
 989             pView->SetActualPage(pPage);
 990             pOutlineShell->UpdatePreview(pPage, true);
 991         }
 992         // Select the first slide.
 993         SdPage* pPage = mrDocument.GetSdPage(0, PK_STANDARD);
 994         pView->SetActualPage(pPage);
 995         pOutlineShell->UpdatePreview(pPage, true);
 996     }
 997
 998     // Undo-Stack needs to be cleared, else the user may remove the
 999     // only drawpage and this is a state we cannot handle ATM.
1000     ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh();
1001     if( pDocShell )
1002         pDocShell->ClearUndoBuffer();
1003 }
1004
1005 } // end of anonymous namespace
1006
1007 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */